Merge pull request #1590 from liam-hq/fix/prisma-parser-support-@@Map

Prisma Parser - Support @@Map

Author: MH4GF

.changeset/breezy-beers-unite.md

@@ -0,0 +1,5 @@
+---
+"@liam-hq/db-structure": minor
+---
+
+update the primsa parser to support the @@map

frontend/packages/db-structure/src/parser/prisma/index.test.ts

@@ -560,6 +560,143 @@ describe(_processor, () => {
       expect(value).toEqual(expectedTables)
     })
 
+    it('@@map', async () => {
+      const { value } = await processor(`
+        model User {
+          id    Int     @id @default(autoincrement()) @map("_id")
+          posts Post[]
+          email String  @unique @map("raw_email_address")
+          role  Role    @default(USER)
+    
+          @@map("users")
+        }
+    
+        model Post {
+          id     Int   @id @default(autoincrement())
+          user   User  @relation(fields: [user_id], references: [id])
+          user_id Int   @map("raw_user_id")
+    
+          @@map("posts")
+        }
+
+        enum Role {
+          USER
+          ADMIN
+        }
+      `)
+
+      const expectedTables = aSchema({
+        tables: {
+          users: aTable({
+            name: 'users',
+            columns: {
+              _id: aColumn({
+                name: '_id',
+                type: 'serial',
+                default: 'autoincrement()',
+                notNull: true,
+                primary: true,
+                unique: true,
+              }),
+              raw_email_address: aColumn({
+                name: 'raw_email_address',
+                type: 'text',
+                notNull: true,
+                unique: true,
+              }),
+              role: aColumn({
+                name: 'role',
+                type: 'Role',
+                notNull: true,
+                default: 'USER',
+              }),
+            },
+            indexes: {
+              users_pkey: anIndex({
+                name: 'users_pkey',
+                columns: ['_id'],
+                unique: true,
+              }),
+              users_raw_email_address_key: anIndex({
+                name: 'users_raw_email_address_key',
+                columns: ['raw_email_address'],
+                unique: true,
+              }),
+            },
+            constraints: {
+              PRIMARY__id: {
+                type: 'PRIMARY KEY',
+                name: 'PRIMARY__id',
+                columnName: '_id',
+              },
+              UNIQUE_raw_email_address: {
+                type: 'UNIQUE',
+                name: 'UNIQUE_raw_email_address',
+                columnName: 'raw_email_address',
+              },
+            },
+          }),
+          posts: aTable({
+            name: 'posts',
+            columns: {
+              id: aColumn({
+                name: 'id',
+                type: 'serial',
+                default: 'autoincrement()',
+                notNull: true,
+                primary: true,
+                unique: true,
+              }),
+              raw_user_id: aColumn({
+                name: 'raw_user_id',
+                type: 'integer',
+                notNull: true,
+                unique: false,
+              }),
+            },
+            indexes: {
+              posts_pkey: anIndex({
+                name: 'posts_pkey',
+                columns: ['id'],
+                unique: true,
+              }),
+            },
+            constraints: {
+              PRIMARY_id: {
+                type: 'PRIMARY KEY',
+                name: 'PRIMARY_id',
+                columnName: 'id',
+              },
+              PostToUser: {
+                type: 'FOREIGN KEY',
+                name: 'PostToUser',
+                columnName: 'raw_user_id',
+                targetTableName: 'users',
+                targetColumnName: '_id',
+                updateConstraint: 'NO_ACTION',
+                deleteConstraint: 'NO_ACTION',
+              },
+            },
+          }),
+        },
+      })
+
+      expectedTables['relationships'] = {
+        PostToUser: aRelationship({
+          name: 'PostToUser',
+          primaryTableName: 'users',
+          primaryColumnName: '_id',
+          foreignTableName: 'posts',
+          foreignColumnName: 'raw_user_id',
+          cardinality: 'ONE_TO_MANY',
+          updateConstraint: 'NO_ACTION',
+          deleteConstraint: 'NO_ACTION',
+        }),
+      }
+
+      expect(value).toEqual(expectedTables)
+    })
+
     it('relationship (implicit many-to-many)', async () => {
       const { value } = await processor(`
         model Post {

frontend/packages/db-structure/src/parser/prisma/parser.ts

@@ -64,9 +64,10 @@ function buildFieldRenamingMap(
   for (const model of models) {
     for (const field of model.fields) {
       if (field.dbName) {
-        const fieldConversions = tableFieldRenaming[model.name] ?? {}
+        const tableName = model.dbName || model.name
+        const fieldConversions = tableFieldRenaming[tableName] ?? {}
         fieldConversions[field.name] = field.dbName
-        tableFieldRenaming[model.name] = fieldConversions
+        tableFieldRenaming[tableName] = fieldConversions
       }
     }
   }
@@ -90,7 +91,9 @@ function processModelField(
   if (field.relationName) return { column: null, constraint: null }
 
   const defaultValue = extractDefaultValue(field)
-  const fieldName = tableFieldRenaming[model.name]?.[field.name] ?? field.name
+
+  const fieldName =
+    tableFieldRenaming[model.dbName || model.name]?.[field.name] ?? field.name
 
   const column = {
     name: fieldName,
@@ -159,7 +162,7 @@ function processModel(
   }
 
   return {
-    name: model.name,
+    name: model.dbName || model.name,
     columns,
     comment: model.documentation ?? null,
     indexes: {},
@@ -177,18 +180,30 @@ function processTables(
   const tables: Record<string, Table> = {}
 
   for (const model of models) {
-    tables[model.name] = processModel(model, tableFieldRenaming)
+    tables[model.dbName || model.name] = processModel(model, tableFieldRenaming)
   }
 
   return tables
 }
 
+/**
+ * Get Primary Table Name
+ */
+
+function getPrimaryTableNameByType(
+  fieldType: string,
+  models: readonly DMMF.Model[],
+) {
+  return models.find((model) => model.name === fieldType)?.dbName ?? fieldType
+}
+
 /**
  * Process a relationship field
  */
 function processRelationshipField(
   field: DMMF.Field,
   model: DMMF.Model,
+  models: readonly DMMF.Model[],
   existingRelationships: Record<string, Relationship>,
   tableFieldRenaming: Record<string, Record<string, string>>,
 ): {
@@ -204,16 +219,20 @@ function processRelationshipField(
     field.relationFromFields?.[0] &&
     (field.relationFromFields?.length ?? 0) > 0
 
+  // Get the primary table name
+  const primaryTableName =
+    isTargetField && getPrimaryTableNameByType(field.type, models)
+
   // Get the column names with fallback to empty string
   const primaryColumnName = field.relationToFields?.[0] ?? ''
   const foreignColumnName = field.relationFromFields?.[0] ?? ''
 
   const _relationship: Relationship = isTargetField
     ? {
         name: field.relationName,
-        primaryTableName: field.type,
+        primaryTableName: primaryTableName || field.type,
         primaryColumnName,
-        foreignTableName: model.name,
+        foreignTableName: model.dbName || model.name,
         foreignColumnName,
         cardinality: existingRelationship?.cardinality ?? 'ONE_TO_MANY',
         updateConstraint: 'NO_ACTION',
@@ -289,6 +308,7 @@ function processModelRelationships(
     const { relationship, constraint } = processRelationshipField(
       field,
       model,
+      models,
       relationships,
       tableFieldRenaming,
     )
@@ -348,10 +368,23 @@ function processRelationships(
  */
 function processIndexes(
   indexes: readonly DMMF.Index[],
+  models: readonly DMMF.Model[],
   tables: Record<string, Table>,
   tableFieldRenaming: Record<string, Record<string, string>>,
 ): void {
-  for (const index of indexes) {
+  const updatedIndexes = indexes.map((index) => {
+    const model = models.find((m) => m.name === index.model)
+    return model
+      ? {
+          model: model.dbName ?? model.name,
+          type: index.type,
+          isDefinedOnField: index.isDefinedOnField,
+          fields: index.fields,
+        }
+      : index
+  })
+
+  for (const index of updatedIndexes) {
     const table = tables[index.model]
     if (!table) continue
 
@@ -470,7 +503,12 @@ async function parsePrismaSchema(schemaString: string): Promise<ProcessResult> {
   )
 
   // Process indexes
-  processIndexes(dmmf.datamodel.indexes, tables, tableFieldRenaming)
+  processIndexes(
+    dmmf.datamodel.indexes,
+    dmmf.datamodel.models,
+    tables,
+    tableFieldRenaming,
+  )
 
   // Process many-to-many relationships
   const manyToManyRelationships = processManyToManyRelationships(