feat: add foreign key indexes (#17672)

server/src/sql-tools/from-code/processors/check-constraint.processor.ts

@@ -1,6 +1,6 @@
 import { onMissingTable, resolveTable } from 'src/sql-tools/from-code/processors/table.processor';
 import { Processor } from 'src/sql-tools/from-code/processors/type';
-import { asCheckConstraintName } from 'src/sql-tools/helpers';
+import { asKey } from 'src/sql-tools/helpers';
 import { DatabaseConstraintType } from 'src/sql-tools/types';
 
 export const processCheckConstraints: Processor = (builder, items) => {
@@ -24,3 +24,5 @@ export const processCheckConstraints: Processor = (builder, items) => {
     });
   }
 };
+
+const asCheckConstraintName = (table: string, expression: string) => asKey('CHK_', table, [expression]);

server/src/sql-tools/from-code/processors/column-index.processor.ts

@@ -1,32 +0,0 @@
-import { onMissingColumn, resolveColumn } from 'src/sql-tools/from-code/processors/column.processor';
-import { onMissingTable } from 'src/sql-tools/from-code/processors/table.processor';
-import { Processor } from 'src/sql-tools/from-code/processors/type';
-import { asIndexName } from 'src/sql-tools/helpers';
-
-export const processColumnIndexes: Processor = (builder, items) => {
-  for (const {
-    item: { object, propertyName, options },
-  } of items.filter((item) => item.type === 'columnIndex')) {
-    const { table, column } = resolveColumn(builder, object, propertyName);
-    if (!table) {
-      onMissingTable(builder, '@ColumnIndex', object);
-      continue;
-    }
-
-    if (!column) {
-      onMissingColumn(builder, `@ColumnIndex`, object, propertyName);
-      continue;
-    }
-
-    table.indexes.push({
-      name: options.name || asIndexName(table.name, [column.name], options.where),
-      tableName: table.name,
-      unique: options.unique ?? false,
-      expression: options.expression,
-      using: options.using,
-      where: options.where,
-      columnNames: [column.name],
-      synchronize: options.synchronize ?? true,
-    });
-  }
-};

server/src/sql-tools/from-code/processors/column.processor.ts

@@ -1,8 +1,8 @@
 import { ColumnOptions } from 'src/sql-tools/from-code/decorators/column.decorator';
 import { onMissingTable, resolveTable } from 'src/sql-tools/from-code/processors/table.processor';
 import { Processor, SchemaBuilder } from 'src/sql-tools/from-code/processors/type';
-import { asMetadataKey, asUniqueConstraintName, fromColumnValue } from 'src/sql-tools/helpers';
-import { DatabaseColumn, DatabaseConstraintType } from 'src/sql-tools/types';
+import { asMetadataKey, fromColumnValue } from 'src/sql-tools/helpers';
+import { DatabaseColumn } from 'src/sql-tools/types';
 
 export const processColumns: Processor = (builder, items) => {
   for (const {
@@ -54,16 +54,6 @@ export const processColumns: Processor = (builder, items) => {
     writeMetadata(object, propertyName, { name: column.name, options });
 
     table.columns.push(column);
-
-    if (type === 'column' && !options.primary && options.unique) {
-      table.constraints.push({
-        type: DatabaseConstraintType.UNIQUE,
-        name: options.uniqueConstraintName || asUniqueConstraintName(table.name, [column.name]),
-        tableName: table.name,
-        columnNames: [column.name],
-        synchronize: options.synchronize ?? true,
-      });
-    }
   }
 };
 

server/src/sql-tools/from-code/processors/foreign-key-constriant.processor.ts

@@ -1,7 +1,7 @@
 import { onMissingColumn, resolveColumn } from 'src/sql-tools/from-code/processors/column.processor';
 import { onMissingTable, resolveTable } from 'src/sql-tools/from-code/processors/table.processor';
 import { Processor } from 'src/sql-tools/from-code/processors/type';
-import { asForeignKeyConstraintName, asRelationKeyConstraintName } from 'src/sql-tools/helpers';
+import { asKey } from 'src/sql-tools/helpers';
 import { DatabaseActionType, DatabaseConstraintType } from 'src/sql-tools/types';
 
 export const processForeignKeyConstraints: Processor = (builder, items) => {
@@ -46,7 +46,7 @@ export const processForeignKeyConstraints: Processor = (builder, items) => {
       synchronize: options.synchronize ?? true,
     });
 
-    if (options.unique) {
+    if (options.unique || options.uniqueConstraintName) {
       table.constraints.push({
         name: options.uniqueConstraintName || asRelationKeyConstraintName(table.name, columnNames),
         tableName: table.name,
@@ -57,3 +57,6 @@ export const processForeignKeyConstraints: Processor = (builder, items) => {
     }
   }
 };
+
+const asForeignKeyConstraintName = (table: string, columns: string[]) => asKey('FK_', table, columns);
+const asRelationKeyConstraintName = (table: string, columns: string[]) => asKey('REL_', table, columns);

server/src/sql-tools/from-code/processors/index.processor.ts

@@ -1,8 +1,9 @@
+import { onMissingColumn, resolveColumn } from 'src/sql-tools/from-code/processors/column.processor';
 import { onMissingTable, resolveTable } from 'src/sql-tools/from-code/processors/table.processor';
 import { Processor } from 'src/sql-tools/from-code/processors/type';
-import { asIndexName } from 'src/sql-tools/helpers';
+import { asKey } from 'src/sql-tools/helpers';
 
-export const processIndexes: Processor = (builder, items) => {
+export const processIndexes: Processor = (builder, items, config) => {
   for (const {
     item: { object, options },
   } of items.filter((item) => item.type === 'index')) {
@@ -24,4 +25,66 @@ export const processIndexes: Processor = (builder, items) => {
       synchronize: options.synchronize ?? true,
     });
   }
+
+  // column indexes
+  for (const {
+    type,
+    item: { object, propertyName, options },
+  } of items.filter((item) => item.type === 'column' || item.type === 'foreignKeyColumn')) {
+    const { table, column } = resolveColumn(builder, object, propertyName);
+    if (!table) {
+      onMissingTable(builder, '@Column', object);
+      continue;
+    }
+
+    if (!column) {
+      // should be impossible since they are created in `column.processor.ts`
+      onMissingColumn(builder, '@Column', object, propertyName);
+      continue;
+    }
+
+    if (options.index === false) {
+      continue;
+    }
+
+    const isIndexRequested =
+      options.indexName || options.index || (type === 'foreignKeyColumn' && config.createForeignKeyIndexes);
+    if (!isIndexRequested) {
+      continue;
+    }
+
+    const indexName = options.indexName || asIndexName(table.name, [column.name]);
+
+    const isIndexPresent = table.indexes.some((index) => index.name === indexName);
+    if (isIndexPresent) {
+      continue;
+    }
+
+    const isOnlyPrimaryColumn = options.primary && table.columns.filter(({ primary }) => primary === true).length === 1;
+    if (isOnlyPrimaryColumn) {
+      // will have an index created by the primary key constraint
+      continue;
+    }
+
+    table.indexes.push({
+      name: indexName,
+      tableName: table.name,
+      unique: false,
+      columnNames: [column.name],
+      synchronize: options.synchronize ?? true,
+    });
+  }
+};
+
+const asIndexName = (table: string, columns?: string[], where?: string) => {
+  const items: string[] = [];
+  for (const columnName of columns ?? []) {
+    items.push(columnName);
+  }
+
+  if (where) {
+    items.push(where);
+  }
+
+  return asKey('IDX_', table, items);
 };

server/src/sql-tools/from-code/processors/primary-key-contraint.processor.ts

@@ -1,5 +1,5 @@
 import { Processor } from 'src/sql-tools/from-code/processors/type';
-import { asPrimaryKeyConstraintName } from 'src/sql-tools/helpers';
+import { asKey } from 'src/sql-tools/helpers';
 import { DatabaseConstraintType } from 'src/sql-tools/types';
 
 export const processPrimaryKeyConstraints: Processor = (builder) => {
@@ -22,3 +22,5 @@ export const processPrimaryKeyConstraints: Processor = (builder) => {
     }
   }
 };
+
+const asPrimaryKeyConstraintName = (table: string, columns: string[]) => asKey('PK_', table, columns);

server/src/sql-tools/from-code/processors/trigger.processor.ts

@@ -1,6 +1,7 @@
+import { TriggerOptions } from 'src/sql-tools/from-code/decorators/trigger.decorator';
 import { onMissingTable, resolveTable } from 'src/sql-tools/from-code/processors/table.processor';
 import { Processor } from 'src/sql-tools/from-code/processors/type';
-import { asTriggerName } from 'src/sql-tools/helpers';
+import { asKey } from 'src/sql-tools/helpers';
 
 export const processTriggers: Processor = (builder, items) => {
   for (const {
@@ -26,3 +27,6 @@ export const processTriggers: Processor = (builder, items) => {
     });
   }
 };
+
+const asTriggerName = (table: string, trigger: TriggerOptions) =>
+  asKey('TR_', table, [...trigger.actions, trigger.scope, trigger.timing, trigger.functionName]);

server/src/sql-tools/from-code/processors/type.ts

@@ -1,3 +1,4 @@
+import { SchemaFromCodeOptions } from 'src/sql-tools/from-code';
 import { TableOptions } from 'src/sql-tools/from-code/decorators/table.decorator';
 import { RegisterItem } from 'src/sql-tools/from-code/register-item';
 import { DatabaseSchema, DatabaseTable } from 'src/sql-tools/types';
@@ -6,4 +7,4 @@ import { DatabaseSchema, DatabaseTable } from 'src/sql-tools/types';
 export type TableWithMetadata = DatabaseTable & { metadata: { options: TableOptions; object: Function } };
 export type SchemaBuilder = Omit<DatabaseSchema, 'tables'> & { tables: TableWithMetadata[] };
 
-export type Processor = (builder: SchemaBuilder, items: RegisterItem[]) => void;
+export type Processor = (builder: SchemaBuilder, items: RegisterItem[], options: SchemaFromCodeOptions) => void;

server/src/sql-tools/from-code/processors/unique-constraint.processor.ts

@@ -1,6 +1,7 @@
+import { onMissingColumn, resolveColumn } from 'src/sql-tools/from-code/processors/column.processor';
 import { onMissingTable, resolveTable } from 'src/sql-tools/from-code/processors/table.processor';
 import { Processor } from 'src/sql-tools/from-code/processors/type';
-import { asUniqueConstraintName } from 'src/sql-tools/helpers';
+import { asKey } from 'src/sql-tools/helpers';
 import { DatabaseConstraintType } from 'src/sql-tools/types';
 
 export const processUniqueConstraints: Processor = (builder, items) => {
@@ -24,4 +25,34 @@ export const processUniqueConstraints: Processor = (builder, items) => {
       synchronize: options.synchronize ?? true,
     });
   }
+
+  // column level constraints
+  for (const {
+    type,
+    item: { object, propertyName, options },
+  } of items.filter((item) => item.type === 'column' || item.type === 'foreignKeyColumn')) {
+    const { table, column } = resolveColumn(builder, object, propertyName);
+    if (!table) {
+      onMissingTable(builder, '@Column', object);
+      continue;
+    }
+
+    if (!column) {
+      // should be impossible since they are created in `column.processor.ts`
+      onMissingColumn(builder, '@Column', object, propertyName);
+      continue;
+    }
+
+    if (type === 'column' && !options.primary && (options.unique || options.uniqueConstraintName)) {
+      table.constraints.push({
+        type: DatabaseConstraintType.UNIQUE,
+        name: options.uniqueConstraintName || asUniqueConstraintName(table.name, [column.name]),
+        tableName: table.name,
+        columnNames: [column.name],
+        synchronize: options.synchronize ?? true,
+      });
+    }
+  }
 };
+
+const asUniqueConstraintName = (table: string, columns: string[]) => asKey('UQ_', table, columns);