feat: naming strategy (#19848)

* feat: naming strategy

* feat: detect renames

Author: jrasm91

server/src/bin/migrations.ts

@@ -9,7 +9,13 @@ import { ConfigRepository } from 'src/repositories/config.repository';
 import { DatabaseRepository } from 'src/repositories/database.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import 'src/schema';
-import { schemaDiff, schemaFromCode, schemaFromDatabase } from 'src/sql-tools';
+import {
+  DefaultNamingStrategy,
+  HashNamingStrategy,
+  schemaDiff,
+  schemaFromCode,
+  schemaFromDatabase,
+} from 'src/sql-tools';
 import { asPostgresConnectionConfig, getKyselyConfig } from 'src/utils/database';
 
 const main = async () => {
@@ -107,7 +113,22 @@ const compare = async () => {
   const { database } = configRepository.getEnv();
   const db = postgres(asPostgresConnectionConfig(database.config));
 
-  const source = schemaFromCode({ overrides: true });
+  const tables = new Set<string>();
+  const preferred = new DefaultNamingStrategy();
+  const fallback = new HashNamingStrategy();
+
+  const source = schemaFromCode({
+    overrides: true,
+    namingStrategy: {
+      getName(item) {
+        if ('tableName' in item && tables.has(item.tableName)) {
+          return preferred.getName(item);
+        }
+
+        return fallback.getName(item);
+      },
+    },
+  });
   const target = await schemaFromDatabase(db, {});
 
   console.log(source.warnings.join('\n'));

server/src/schema/tables/stack.table.ts

@@ -35,7 +35,11 @@ export class StackTable {
   updateId!: Generated<string>;
 
   //TODO: Add constraint to ensure primary asset exists in the assets array
-  @ForeignKeyColumn(() => AssetTable, { nullable: false, unique: true })
+  @ForeignKeyColumn(() => AssetTable, {
+    nullable: false,
+    unique: true,
+    uniqueConstraintName: 'REL_91704e101438fd0653f582426d',
+  })
   primaryAssetId!: string;
 
   @ForeignKeyColumn(() => UserTable, { onDelete: 'CASCADE', onUpdate: 'CASCADE' })

server/src/sql-tools/comparers/column.comparer.spec.ts

@@ -5,6 +5,7 @@ import { describe, expect, it } from 'vitest';
 const testColumn: DatabaseColumn = {
   name: 'test',
   tableName: 'table1',
+  primary: false,
   nullable: false,
   isArray: false,
   type: 'character varying',

server/src/sql-tools/comparers/column.comparer.ts

@@ -1,7 +1,32 @@
-import { getColumnType, isDefaultEqual } from 'src/sql-tools/helpers';
+import { asRenameKey, getColumnType, isDefaultEqual } from 'src/sql-tools/helpers';
 import { Comparer, DatabaseColumn, Reason, SchemaDiff } from 'src/sql-tools/types';
 
-export const compareColumns: Comparer<DatabaseColumn> = {
+export const compareColumns = {
+  getRenameKey: (column) => {
+    return asRenameKey([
+      column.tableName,
+      column.type,
+      column.nullable,
+      column.default,
+      column.storage,
+      column.primary,
+      column.isArray,
+      column.length,
+      column.identity,
+      column.enumName,
+      column.numericPrecision,
+      column.numericScale,
+    ]);
+  },
+  onRename: (source, target) => [
+    {
+      type: 'ColumnRename',
+      tableName: source.tableName,
+      oldName: target.name,
+      newName: source.name,
+      reason: Reason.Rename,
+    },
+  ],
   onMissing: (source) => [
     {
       type: 'ColumnAdd',
@@ -67,7 +92,7 @@ export const compareColumns: Comparer<DatabaseColumn> = {
 
     return items;
   },
-};
+} satisfies Comparer<DatabaseColumn>;
 
 const dropAndRecreateColumn = (source: DatabaseColumn, target: DatabaseColumn, reason: string): SchemaDiff[] => {
   return [

server/src/sql-tools/comparers/constraint.comparer.ts

@@ -1,4 +1,4 @@
-import { haveEqualColumns } from 'src/sql-tools/helpers';
+import { asRenameKey, haveEqualColumns } from 'src/sql-tools/helpers';
 import {
   CompareFunction,
   Comparer,
@@ -13,6 +13,37 @@ import {
 } from 'src/sql-tools/types';
 
 export const compareConstraints: Comparer<DatabaseConstraint> = {
+  getRenameKey: (constraint) => {
+    switch (constraint.type) {
+      case ConstraintType.PRIMARY_KEY:
+      case ConstraintType.UNIQUE: {
+        return asRenameKey([constraint.type, constraint.tableName, ...constraint.columnNames.toSorted()]);
+      }
+
+      case ConstraintType.FOREIGN_KEY: {
+        return asRenameKey([
+          constraint.type,
+          constraint.tableName,
+          ...constraint.columnNames.toSorted(),
+          constraint.referenceTableName,
+          ...constraint.referenceColumnNames.toSorted(),
+        ]);
+      }
+
+      case ConstraintType.CHECK: {
+        return asRenameKey([constraint.type, constraint.tableName, constraint.expression]);
+      }
+    }
+  },
+  onRename: (source, target) => [
+    {
+      type: 'ConstraintRename',
+      tableName: target.tableName,
+      oldName: target.name,
+      newName: source.name,
+      reason: Reason.Rename,
+    },
+  ],
   onMissing: (source) => [
     {
       type: 'ConstraintAdd',

server/src/sql-tools/comparers/index.comparer.ts

@@ -1,7 +1,23 @@
-import { haveEqualColumns } from 'src/sql-tools/helpers';
+import { asRenameKey, haveEqualColumns } from 'src/sql-tools/helpers';
 import { Comparer, DatabaseIndex, Reason } from 'src/sql-tools/types';
 
 export const compareIndexes: Comparer<DatabaseIndex> = {
+  getRenameKey: (index) => {
+    if (index.override) {
+      return index.override.value.sql.replace(index.name, 'INDEX_NAME');
+    }
+
+    return asRenameKey([index.tableName, ...(index.columnNames || []).toSorted(), index.unique]);
+  },
+  onRename: (source, target) => [
+    {
+      type: 'IndexRename',
+      tableName: source.tableName,
+      oldName: target.name,
+      newName: source.name,
+      reason: Reason.Rename,
+    },
+  ],
   onMissing: (source) => [
     {
       type: 'IndexCreate',

server/src/sql-tools/contexts/base-context.ts

@@ -1,3 +1,6 @@
+import { DefaultNamingStrategy } from 'src/sql-tools/naming/default.naming';
+import { HashNamingStrategy } from 'src/sql-tools/naming/hash.naming';
+import { NamingInterface, NamingItem } from 'src/sql-tools/naming/naming.interface';
 import {
   BaseContextOptions,
   DatabaseEnum,
@@ -11,6 +14,26 @@ import {
 
 const asOverrideKey = (type: string, name: string) => `${type}:${name}`;
 
+const isNamingInterface = (strategy: any): strategy is NamingInterface => {
+  return typeof strategy === 'object' && typeof strategy.getName === 'function';
+};
+
+const asNamingStrategy = (strategy: 'hash' | 'default' | NamingInterface): NamingInterface => {
+  if (isNamingInterface(strategy)) {
+    return strategy;
+  }
+
+  switch (strategy) {
+    case 'hash': {
+      return new HashNamingStrategy();
+    }
+
+    default: {
+      return new DefaultNamingStrategy();
+    }
+  }
+};
+
 export class BaseContext {
   databaseName: string;
   schemaName: string;
@@ -24,10 +47,17 @@ export class BaseContext {
   overrides: DatabaseOverride[] = [];
   warnings: string[] = [];
 
+  private namingStrategy: NamingInterface;
+
   constructor(options: BaseContextOptions) {
     this.databaseName = options.databaseName ?? 'postgres';
     this.schemaName = options.schemaName ?? 'public';
     this.overrideTableName = options.overrideTableName ?? 'migration_overrides';
+    this.namingStrategy = asNamingStrategy(options.namingStrategy ?? 'hash');
+  }
+
+  getNameFor(item: NamingItem) {
+    return this.namingStrategy.getName(item);
   }
 
   getTableByName(name: string) {

server/src/sql-tools/contexts/processor-context.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 import { BaseContext } from 'src/sql-tools/contexts/base-context';
-import { ColumnOptions, TableOptions } from 'src/sql-tools/decorators';
-import { asKey } from 'src/sql-tools/helpers';
+import { ColumnOptions } from 'src/sql-tools/decorators/column.decorator';
+import { TableOptions } from 'src/sql-tools/decorators/table.decorator';
 import { DatabaseColumn, DatabaseTable, SchemaFromCodeOptions } from 'src/sql-tools/types';
 
 type TableMetadata = { options: TableOptions; object: Function; methodToColumn: Map<string | symbol, DatabaseColumn> };
@@ -59,19 +59,6 @@ export class ProcessorContext extends BaseContext {
     tableMetadata.methodToColumn.set(propertyName, column);
   }
 
-  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);
-  }
-
   warnMissingTable(context: string, object: object, propertyName?: symbol | string) {
     const label = object.constructor.name + (propertyName ? '.' + String(propertyName) : '');
     this.warn(context, `Unable to find table (${label})`);

server/src/sql-tools/decorators/index.ts

@@ -2,13 +2,6 @@ import { createHash } from 'node:crypto';
 import { ColumnValue } from 'src/sql-tools/decorators/column.decorator';
 import { Comparer, DatabaseColumn, DatabaseOverride, IgnoreOptions, SchemaDiff } from 'src/sql-tools/types';
 
-export const asMetadataKey = (name: string) => `sql-tools:${name}`;
-
-export const asSnakeCase = (name: string): string => name.replaceAll(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
-// match TypeORM
-export const asKey = (prefix: string, tableName: string, values: string[]) =>
-  (prefix + sha1(`${tableName}_${values.toSorted().join('_')}`)).slice(0, 30);
-
 export const asOptions = <T extends { name?: string }>(options: string | T): T => {
   if (typeof options === 'string') {
     return { name: options } as T;
@@ -79,6 +72,10 @@ export const compare = <T extends { name: string; synchronize: boolean }>(
   const items: SchemaDiff[] = [];
 
   const keys = new Set([...Object.keys(sourceMap), ...Object.keys(targetMap)]);
+  const missingKeys = new Set<string>();
+  const extraKeys = new Set<string>();
+
+  // common keys
   for (const key of keys) {
     const source = sourceMap[key];
     const target = targetMap[key];
@@ -92,22 +89,63 @@ export const compare = <T extends { name: string; synchronize: boolean }>(
     }
 
     if (source && !target) {
-      items.push(...comparer.onMissing(source));
-    } else if (!source && target) {
-      items.push(...comparer.onExtra(target));
-    } else {
-      if (
-        haveEqualOverrides(
-          source as unknown as { override?: DatabaseOverride },
-          target as unknown as { override?: DatabaseOverride },
-        )
-      ) {
+      missingKeys.add(key);
+      continue;
+    }
+
+    if (!source && target) {
+      extraKeys.add(key);
+      continue;
+    }
+
+    if (
+      haveEqualOverrides(
+        source as unknown as { override?: DatabaseOverride },
+        target as unknown as { override?: DatabaseOverride },
+      )
+    ) {
+      continue;
+    }
+
+    items.push(...comparer.onCompare(source, target));
+  }
+
+  // renames
+  if (comparer.getRenameKey && comparer.onRename) {
+    const renameMap: Record<string, string> = {};
+    for (const sourceKey of missingKeys) {
+      const source = sourceMap[sourceKey];
+      const renameKey = comparer.getRenameKey(source);
+      renameMap[renameKey] = sourceKey;
+    }
+
+    for (const targetKey of extraKeys) {
+      const target = targetMap[targetKey];
+      const renameKey = comparer.getRenameKey(target);
+      const sourceKey = renameMap[renameKey];
+      if (!sourceKey) {
         continue;
       }
-      items.push(...comparer.onCompare(source, target));
+
+      const source = sourceMap[sourceKey];
+
+      items.push(...comparer.onRename(source, target));
+
+      missingKeys.delete(sourceKey);
+      extraKeys.delete(targetKey);
     }
   }
 
+  // missing
+  for (const key of missingKeys) {
+    items.push(...comparer.onMissing(sourceMap[key]));
+  }
+
+  // extra
+  for (const key of extraKeys) {
+    items.push(...comparer.onExtra(targetMap[key]));
+  }
+
   return items;
 };
 
@@ -186,8 +224,6 @@ export const asColumnComment = (tableName: string, columnName: string, comment:
 
 export const asColumnList = (columns: string[]) => columns.map((column) => `"${column}"`).join(', ');
 
-export const asForeignKeyConstraintName = (table: string, columns: string[]) => asKey('FK_', table, [...columns]);
-
 export const asJsonString = (value: unknown): string => {
   return `'${escape(JSON.stringify(value))}'::jsonb`;
 };
@@ -202,3 +238,6 @@ const escape = (value: string) => {
     .replaceAll(/[\r]/g, String.raw`\r`)
     .replaceAll(/[\t]/g, String.raw`\t`);
 };
+
+export const asRenameKey = (values: Array<string | boolean | number | undefined>) =>
+  values.map((value) => value ?? '').join('|');