feat(many-to-many): generate join table

* for m-n-relations

Author: marcjulian

__tests__/dbml.test.ts

@@ -2,6 +2,7 @@ import {
   datamodelDbml,
   datamodelDbmlComments,
   datamodelDbmlDefaults,
+  datamodelDbmlManyToMany,
   datamodelDbmlRelations,
 } from './fixtures/dbml.datamodel';
 import { generateDMMF } from './utils/generateDMMF';
@@ -142,4 +143,44 @@ Ref: Post.authorId > User.id`;
 
     expect(dbml).toEqual(expectedDbml);
   });
+
+  test('generating dbml schema with many-to-many relationship', async () => {
+    const dmmf = await generateDMMF(datamodelDbmlManyToMany);
+
+    const expectedDbml = `${autoGeneratedComment}
+
+Table Post {
+  id Int [pk, increment]
+  categories Category
+}
+
+Table Category {
+  id Int [pk, increment]
+  posts Post
+}
+
+Table Author {
+  id Int [pk, increment]
+  books Book
+}
+
+Table Book {
+  id Int [pk, increment]
+  authors Author
+}
+
+Table CategoryToPost {
+  categoryId Int [ref: > Category.id]
+  postId Int [ref: > Post.id]
+}
+
+Table AuthorToBook {
+  bookId Int [ref: > Book.id]
+  authorId Int [ref: > Author.id]
+}`;
+
+    const dbml = generateDBMLSchema(dmmf);
+
+    expect(dbml).toEqual(expectedDbml);
+  });
 });

__tests__/fixtures/dbml.datamodel.ts

@@ -79,3 +79,25 @@ export const datamodelDbmlComments = /* Prisma */ `
     USER
   }
 `;
+
+export const datamodelDbmlManyToMany = /* Prisma */ `
+  model Post {
+    id         Int        @id @default(autoincrement())
+    categories Category[]
+  }
+
+  model Category {
+    id    Int    @id @default(autoincrement())
+    posts Post[]
+  }
+
+  model Author {
+    id         Int        @id @default(autoincrement())
+    books Book[]
+  }
+
+  model Book {
+    id    Int    @id @default(autoincrement())
+    authors Author[]
+  }
+`;

prisma/dbml/schema.dbml

@@ -0,0 +1,33 @@
+//// ------------------------------------------------------
+//// THIS FILE WAS AUTOMATICALLY GENERATED (DO NOT MODIFY)
+//// ------------------------------------------------------
+
+Table Post {
+  id Int [pk, increment]
+  categories Category
+}
+
+Table Category {
+  id Int [pk, increment]
+  posts Post
+}
+
+Table Author {
+  id Int [pk, increment]
+  books Book
+}
+
+Table Book {
+  id String [pk]
+  authors Author
+}
+
+Table CategoryToPost {
+  categoryId Int [ref: > Category.id]
+  postId Int [ref: > Post.id]
+}
+
+Table AuthorToBook {
+  bookId String [ref: > Book.id]
+  authorId Int [ref: > Author.id]
+}

prisma/schema.prisma

@@ -11,9 +11,7 @@ generator client {
 }
 
 generator dbml {
-  provider   = "node ./dist/generator.js"
-  output     = "../dbml"
-  outputName = "awesome.dbml"
+  provider = "node ./dist/generator.js"
 }
 
 model User {

src/generator/dbml.ts

@@ -2,15 +2,23 @@ import { DMMF } from '@prisma/generator-helper';
 import { generateTables } from './table';
 import { generateEnums } from './enums';
 import { generateRelations } from './relations';
+import { generateManyToManyTables } from './many-to-many-tables';
 
 export const autoGeneratedComment = `//// ------------------------------------------------------
 //// THIS FILE WAS AUTOMATICALLY GENERATED (DO NOT MODIFY)
 //// ------------------------------------------------------`;
 
 export function generateDBMLSchema(dmmf: DMMF.Document): string {
   const tables = generateTables(dmmf.datamodel.models);
+  const manyToManyTables = generateManyToManyTables(dmmf.datamodel.models);
   const enums = generateEnums(dmmf.datamodel.enums);
   const refs = generateRelations(dmmf.datamodel.models);
 
-  return [autoGeneratedComment, ...tables, ...enums, ...refs].join('\n\n');
+  return [
+    autoGeneratedComment,
+    ...tables,
+    ...manyToManyTables,
+    ...enums,
+    ...refs,
+  ].join('\n\n');
 }

src/generator/many-to-many-tables.ts

@@ -0,0 +1,79 @@
+import { DMMF } from '@prisma/generator-helper';
+
+export function generateManyToManyTables(models: DMMF.Model[]): string[] {
+  const manyToManyFields = filterManyToManyRelationFields(models);
+  if (manyToManyFields.length === 0) {
+    return [];
+  }
+
+  return generateTables(manyToManyFields, models);
+}
+
+function generateTables(
+  manyToManyFields: DMMF.Field[],
+  models: DMMF.Model[],
+  manyToManyTables: string[] = []
+): string[] {
+  const manyFirst = manyToManyFields.shift();
+  if (!manyFirst) {
+    return manyToManyTables;
+  }
+
+  const manySecond = manyToManyFields.find(
+    (field) => field.relationName === manyFirst.relationName
+  )!;
+
+  manyToManyTables.push(
+    `Table ${manyFirst?.relationName} {\n` +
+      `${generateJoinFields([manyFirst, manySecond], models)}` +
+      '\n}'
+  );
+
+  return generateTables(
+    manyToManyFields.filter(
+      (field) => field.relationName !== manyFirst.relationName
+    ),
+    models,
+    manyToManyTables
+  );
+}
+
+function generateJoinFields(field: DMMF.Field[], models: DMMF.Model[]): string {
+  return field.map((field) => joinField(field, models)).join('\n');
+}
+
+function joinField(field: DMMF.Field, models: DMMF.Model[]): string {
+  return `  ${field.type.toLowerCase()}Id ${getJoinIdType(
+    field,
+    models
+  )} [ref: > ${field.type}.${field.relationToFields![0]}]`;
+}
+
+function getJoinIdType(joinField: DMMF.Field, models: DMMF.Model[]): string {
+  const joinIdField = models
+    .filter((model) => model.name === joinField.type)
+    .map(
+      (model) =>
+        model.fields.find(
+          (field) => field.name === joinField.relationToFields![0]
+        )!
+    )[0];
+
+  return joinIdField.type;
+}
+
+function filterManyToManyRelationFields(models: DMMF.Model[]): DMMF.Field[] {
+  return models
+    .map((model) =>
+      model.fields
+        .filter(
+          (field) =>
+            field.relationName &&
+            field.isList &&
+            field.relationFromFields?.length === 0 &&
+            field.relationToFields?.length
+        )
+        .map((field) => field)
+    )
+    .flat();
+}