feat(indexes): include block level unique indexes

Author: marcjulian

__tests__/fixtures/table.datamodel.ts

@@ -1,3 +1,5 @@
+import { datamodelDbml } from './dbml.datamodel';
+import { datamodelOneToOneAndManyToOne } from './relations.datamodel';
 export const datamodelSingleTable = /* Prisma */ `
   model User {
     id Int @id @default(autoincrement())
@@ -13,3 +15,46 @@ export const datamodelTableWithStringDefaults = /* Prisma */ `
     color String @default("blue")
   }
 `;
+
+export const datamodelTableWithSingleCompositeUniqueIndex = /* Prisma */ `
+  model A {
+    id Int @id @default(autoincrement())
+    b String
+
+    @@unique([b])
+  }
+`;
+
+export const datamodelTableWithThreeFieldsCompositeUniqueIndex = /* Prisma */ `
+  model A {
+    id Int @id @default(autoincrement())
+    b String
+    c Int
+    d DateTime
+
+    @@unique([d, b, c])
+  }
+`;
+
+export const datamodelTableWithOneCompositeUniqueIndex = /* Prisma */ `
+  model Token {
+    id Int @id @default(autoincrement())
+    device String
+    operatingSystem String
+
+    @@unique([device, operatingSystem])
+  }
+`;
+
+export const datamodelTableWithTwoCompositeUniqueIndex = /* Prisma */ `
+  model A {
+    id Int @id @default(autoincrement())
+    b String
+    c String
+    d Int
+    e DateTime
+
+    @@unique([b, d])
+    @@unique([e, c])
+  }
+`;

__tests__/table.test.ts

@@ -1,6 +1,10 @@
 import {
   datamodelSingleTable,
+  datamodelTableWithOneCompositeUniqueIndex,
+  datamodelTableWithSingleCompositeUniqueIndex,
   datamodelTableWithStringDefaults,
+  datamodelTableWithThreeFieldsCompositeUniqueIndex,
+  datamodelTableWithTwoCompositeUniqueIndex,
 } from './fixtures/table.datamodel';
 import { generateDMMF } from './utils/generateDMMF';
 import { generateTables } from '../src/generator/table';
@@ -33,4 +37,87 @@ describe('Tables', () => {
     expect(enums.length).toEqual(1);
     expect(enums[0]).toMatch(expected);
   });
+
+  test('generate a table with single composite unique index', async () => {
+    const dmmf = await generateDMMF(
+      datamodelTableWithSingleCompositeUniqueIndex
+    );
+
+    const expected = `Table A {
+  id Int [pk, increment]
+  b String [not null]
+
+  indexes {
+    (b) [unique]
+  }
+}`;
+
+    const enums = generateTables(dmmf.datamodel.models);
+
+    expect(enums.length).toEqual(1);
+    expect(enums[0]).toMatch(expected);
+  });
+
+  test('generate a table with three fields as composite unique index', async () => {
+    const dmmf = await generateDMMF(
+      datamodelTableWithThreeFieldsCompositeUniqueIndex
+    );
+
+    const expected = `Table A {
+  id Int [pk, increment]
+  b String [not null]
+  c Int [not null]
+  d DateTime [not null]
+
+  indexes {
+    (d, b, c) [unique]
+  }
+}`;
+
+    const enums = generateTables(dmmf.datamodel.models);
+
+    expect(enums.length).toEqual(1);
+    expect(enums[0]).toMatch(expected);
+  });
+
+  test('generate a table with one composite unique index', async () => {
+    const dmmf = await generateDMMF(datamodelTableWithOneCompositeUniqueIndex);
+
+    const expected = `Table Token {
+  id Int [pk, increment]
+  device String [not null]
+  operatingSystem String [not null]
+
+  indexes {
+    (device, operatingSystem) [unique]
+  }
+}`;
+
+    const enums = generateTables(dmmf.datamodel.models);
+
+    expect(enums.length).toEqual(1);
+    expect(enums[0]).toMatch(expected);
+  });
+
+  test('generate a table with two composite unique index', async () => {
+    const dmmf = await generateDMMF(datamodelTableWithTwoCompositeUniqueIndex);
+
+    const expected = `Table A {
+  id Int [pk, increment]
+  b String [not null]
+  c String [not null]
+  d Int [not null]
+  e DateTime [not null]
+
+  indexes {
+    (b, d) [unique]
+    (e, c) [unique]
+  }
+}`;
+
+    const enums = generateTables(dmmf.datamodel.models);
+
+    expect(enums.length).toEqual(1);
+    expect(enums[0]).toMatch(expected);
+  });
 });

prisma/dbml/schema.dbml

@@ -38,6 +38,16 @@ Table Category {
   posts Post
 }
 
+Table Token {
+  id Int [pk, increment]
+  device String [not null]
+  operatingSystem String [not null]
+
+  indexes {
+    (device, operatingSystem) [unique]
+  }
+}
+
 Table CategoryToPost {
   categoriesId Int [ref: > Category.id]
   postsId Int [ref: > Post.id]

prisma/schema.prisma

@@ -28,7 +28,7 @@ model User {
 
 /// User profile
 model Profile {
-  id     Int     @default(autoincrement()) @id
+  id     Int     @id @default(autoincrement())
   bio    String?
   user   User    @relation(fields: [userId], references: [id])
   userId Int     @unique
@@ -50,6 +50,14 @@ model Category {
   posts Post[]
 }
 
+model Token {
+  id              Int    @id @default(autoincrement())
+  device          String
+  operatingSystem String
+
+  @@unique([device, operatingSystem])
+}
+
 /// user role
 enum Role {
   ADMIN /// allowed to do everything

src/cli/dbml-generator.ts

@@ -17,7 +17,7 @@ export async function generate(options: GeneratorOptions) {
   try {
     await mkdir(outputDir, { recursive: true });
 
-    // await writeFile('./test.json', JSON.stringify(options.dmmf.datamodel));
+    await writeFile('./test.json', JSON.stringify(options.dmmf.datamodel));
 
     const dbmlSchema = generateDBMLSchema(options.dmmf, allowManyToMany);
 

src/generator/table.ts

@@ -1,15 +1,35 @@
+import { DBMLKeywords } from './../keywords';
 import { DMMF } from '@prisma/generator-helper';
 
 export function generateTables(models: DMMF.Model[]): string[] {
   return models.map(
     (model) =>
-      `Table ${model.name} {\n` +
+      `${DBMLKeywords.Table} ${model.name} {\n` +
       generateFields(model.fields) +
+      generateTableIndexes(model) +
       generateTableDocumentation(model) +
       '\n}'
   );
 }
 
+const generateTableIndexes = (model: DMMF.Model): string => {
+  const hasTableIndexes =
+    model.idFields.length > 0 || model.uniqueFields.length > 0;
+  return hasTableIndexes
+    ? `\n\n  ${DBMLKeywords.Indexes} {\n${generateTableUniqueFields(
+        model.uniqueFields
+      )}\n  }`
+    : '';
+};
+
+const generateTableUniqueFields = (uniqueFields: string[][]): string => {
+  return uniqueFields
+    .map(
+      (composite) => `    (${composite.join(', ')}) [${DBMLKeywords.Unique}]`
+    )
+    .join('\n');
+};
+
 const generateTableDocumentation = (model: DMMF.Model): string => {
   const doc = model.documentation;
   return doc ? `\n\n  Note: '${doc}'` : '';
@@ -27,35 +47,35 @@ const generateFields = (fields: DMMF.Field[]): string => {
 const generateColumnDefinition = (field: DMMF.Field): string => {
   const columnDefinition = [];
   if (field.isId) {
-    columnDefinition.push('pk');
+    columnDefinition.push(DBMLKeywords.Pk);
   }
 
   if ((field.default as DMMF.FieldDefault)?.name === 'autoincrement') {
-    columnDefinition.push('increment');
+    columnDefinition.push(DBMLKeywords.Increment);
   }
 
   if ((field.default as DMMF.FieldDefault)?.name === 'now') {
     columnDefinition.push('default: `now()`');
   }
 
   if (field.isUnique) {
-    columnDefinition.push('unique');
+    columnDefinition.push(DBMLKeywords.Unique);
   }
 
   if (field.isRequired && !field.isId) {
-    columnDefinition.push('not null');
+    columnDefinition.push(DBMLKeywords.NotNull);
   }
 
   if (field.hasDefaultValue && typeof field.default != 'object') {
     if (field.type === 'String' || field.kind === 'enum') {
-      columnDefinition.push(`default: '${field.default}'`);
+      columnDefinition.push(`${DBMLKeywords.Default}: '${field.default}'`);
     } else {
-      columnDefinition.push(`default: ${field.default}`);
+      columnDefinition.push(`${DBMLKeywords.Default}: ${field.default}`);
     }
   }
 
   if (field.documentation) {
-    columnDefinition.push(`note: '${field.documentation}'`);
+    columnDefinition.push(`${DBMLKeywords.Note}: '${field.documentation}'`);
   }
 
   if (columnDefinition.length) {

src/keywords.ts

@@ -0,0 +1,10 @@
+export enum DBMLKeywords {
+  Default = 'default',
+  Increment = 'increment',
+  Note = 'note',
+  NotNull = 'not null',
+  Table = 'Table',
+  Unique = 'unique',
+  Pk = 'pk',
+  Indexes = 'indexes',
+}