metal-orm 1.1.26 → 1.1.27

package/src/core/ddl/dialects/postgres-schema-dialect.ts

@@ -1,174 +1,183 @@
-import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
-import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef, ForeignKeyReference, normalizeColumnType, renderTypeWithArgs } from '../../../schema/column-types.js';
-import { IndexDef, TableDef } from '../../../schema/table.js';
-import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
-import { DialectName } from '../schema-dialect.js';
-
-/** PostgreSQL schema dialect implementation. */
-export class PostgresSchemaDialect extends BaseSchemaDialect {
-  readonly name: DialectName = 'postgres';
-
-  private _literalFormatter = createLiteralFormatter({
-    booleanTrue: 'TRUE',
-    booleanFalse: 'FALSE',
-  });
-
-  get literalFormatter() {
-    return this._literalFormatter;
+import {
+  createLiteralFormatter,
+  renderIndexColumns
+} from '../sql-writing.js';
+import {
+  composeSchemaDialect,
+  createStandardDropColumnCapability,
+  createStandardDropTableCapability,
+  type SchemaDialectServices
+} from '../schema-dialect-composer.js';
+import type { SchemaDialect } from '../schema-dialect.js';
+import {
+  normalizeColumnType,
+  renderTypeWithArgs,
+  type ColumnDef
+} from '../../../schema/column-types.js';
+import type { IndexDef, TableDef } from '../../../schema/table.js';
+import type { DatabaseTable } from '../schema-types.js';
+
+const quoteIdentifier = (id: string): string => `"${id}"`;
+const literalFormatter = createLiteralFormatter();
+
+const renderPostgresColumnType = (
+  column: ColumnDef,
+  services: SchemaDialectServices
+): string => {
+  const override = column.dialectTypes?.[services.name] ?? column.dialectTypes?.default;
+  if (override) return renderTypeWithArgs(override, column.args);
+
+  const type = normalizeColumnType(column.type);
+  switch (type) {
+    case 'int':
+    case 'integer': return 'integer';
+    case 'bigint': return 'bigint';
+    case 'uuid': return 'uuid';
+    case 'boolean': return 'boolean';
+    case 'json': return 'jsonb';
+    case 'decimal':
+      return column.args?.length ? `numeric(${column.args[0]}, ${column.args[1] ?? 0})` : 'numeric';
+    case 'float':
+    case 'double': return 'double precision';
+    case 'timestamptz': return 'timestamptz';
+    case 'timestamp': return 'timestamp';
+    case 'date': return 'date';
+    case 'datetime': return 'timestamp';
+    case 'varchar': return column.args?.length ? `varchar(${column.args[0]})` : 'varchar';
+    case 'text': return 'text';
+    case 'enum': return 'text';
+    case 'binary':
+    case 'varbinary':
+    case 'blob':
+    case 'bytea': return 'bytea';
+    case 'vector':
+      return column.vectorOptions?.elementType === 'float16'
+        ? `halfvec(${column.vectorOptions.dimensions})`
+        : column.args?.length
+          ? `vector(${column.args[0]})`
+          : 'vector';
+    case 'halfvec': return column.args?.length ? `halfvec(${column.args[0]})` : 'halfvec';
+    default: return renderTypeWithArgs(String(type).toLowerCase(), column.args);
   }
-
-  quoteIdentifier(id: string): string {
-    return `"${id}"`;
-  }
-
-  renderColumnType(column: ColumnDef): string {
-    const override = column.dialectTypes?.[this.name] ?? column.dialectTypes?.default;
-    if (override) {
-      return renderTypeWithArgs(override, column.args);
-    }
-
-    const type = normalizeColumnType(column.type);
-    switch (type) {
-      case 'int':
-      case 'integer':
-        return 'integer';
-      case 'bigint':
-        return 'bigint';
-      case 'uuid':
-        return 'uuid';
-      case 'boolean':
-        return 'boolean';
-      case 'json':
-        return 'jsonb';
-      case 'decimal':
-        return column.args?.length ? `numeric(${column.args[0]}, ${column.args[1] ?? 0})` : 'numeric';
-      case 'float':
-      case 'double':
-        return 'double precision';
-      case 'timestamptz':
-        return 'timestamptz';
-      case 'timestamp':
-        return 'timestamp';
-      case 'date':
-        return 'date';
-      case 'datetime':
-        return 'timestamp';
-      case 'varchar':
-        return column.args?.length ? `varchar(${column.args[0]})` : 'varchar';
-      case 'text':
-        return 'text';
-      case 'enum':
-        return 'text';
-      case 'binary':
-      case 'varbinary':
-      case 'blob':
-      case 'bytea':
-        return 'bytea';
-      case 'vector':
-        return column.vectorOptions?.elementType === 'float16'
-          ? `halfvec(${column.vectorOptions.dimensions})`
-          : column.args?.length
-            ? `vector(${column.args[0]})`
-            : 'vector';
-      case 'halfvec':
-        return column.args?.length ? `halfvec(${column.args[0]})` : 'halfvec';
-      default:
-        return renderTypeWithArgs(String(type).toLowerCase(), column.args);
+};
+
+const renderPostgresIndex = (
+  table: TableDef,
+  index: IndexDef,
+  services: SchemaDialectServices
+): string => {
+  const name = index.name || deriveIndexName(table, index);
+  let columns = renderIndexColumns(services, index.columns);
+  if (index.ops) columns = `${columns} ${index.ops}`;
+  const unique = index.unique ? 'UNIQUE ' : '';
+  const using = index.using ? ` USING ${index.using}` : '';
+  let withClause = '';
+  if (index.with) {
+    if (typeof index.with === 'string') {
+      withClause = ` WITH (${index.with})`;
+    } else {
+      const params = Object.entries(index.with).map(([key, value]) => `${key} = ${value}`).join(', ');
+      withClause = ` WITH (${params})`;
     }
   }
-
-  renderAutoIncrement(column: ColumnDef): string | undefined {
-    if (!column.autoIncrement) return undefined;
-    const strategy = column.generated === 'always' ? 'GENERATED ALWAYS' : 'GENERATED BY DEFAULT';
-    return `${strategy} AS IDENTITY`;
-  }
-
-  renderIndex(table: TableDef, index: IndexDef): string {
-    const name = index.name || deriveIndexName(table, index);
-    let cols = renderIndexColumns(this, index.columns);
-    if (index.ops) {
-      cols = `${cols} ${index.ops}`;
-    }
-    const unique = index.unique ? 'UNIQUE ' : '';
-    const using = index.using ? ` USING ${index.using}` : '';
-    let withClause = '';
-    if (index.with) {
-      if (typeof index.with === 'string') {
-        withClause = ` WITH (${index.with})`;
-      } else {
-        const params = Object.entries(index.with).map(([k, v]) => `${k} = ${v}`).join(', ');
-        withClause = ` WITH (${params})`;
+  const where = index.where ? ` WHERE ${index.where}` : '';
+  return `CREATE ${unique}INDEX IF NOT EXISTS ${services.quoteIdentifier(name)} ON ${services.formatTableName(table)}${using} (${columns})${withClause}${where};`;
+};
+
+export const createPostgresSchemaDialect = (): SchemaDialect =>
+  composeSchemaDialect({
+    name: 'postgres',
+    quoteIdentifier,
+    literalFormatter,
+    renderColumnType: renderPostgresColumnType,
+    renderAutoIncrement: column => {
+      if (!column.autoIncrement) return undefined;
+      const strategy = column.generated === 'always' ? 'GENERATED ALWAYS' : 'GENERATED BY DEFAULT';
+      return `${strategy} AS IDENTITY`;
+    },
+    renderIndex: renderPostgresIndex,
+    renderReferenceSuffix: ref => ref.deferrable ? 'DEFERRABLE INITIALLY DEFERRED' : undefined,
+    supportsPartialIndexes: true,
+    mutations: services => ({
+      dropTable: createStandardDropTableCapability(services),
+      dropColumn: createStandardDropColumnCapability(services),
+      dropIndex: {
+        compile(table, index) {
+          const qualified = table.schema
+            ? `${services.quoteIdentifier(table.schema)}.${services.quoteIdentifier(index)}`
+            : services.quoteIdentifier(index);
+          return [`DROP INDEX IF EXISTS ${qualified};`];
+        }
+      },
+      alterColumn: {
+        compile(table, column, actualColumn, diff) {
+          void actualColumn;
+          const statements: string[] = [];
+          const tableName = services.formatTableName(table);
+          const columnName = services.quoteIdentifier(column.name);
+
+          if (diff.typeChanged) {
+            statements.push(
+              `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${renderPostgresColumnType(column, services)};`
+            );
+          }
+          if (diff.defaultChanged) {
+            statements.push(
+              column.default === undefined
+                ? `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT;`
+                : `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${services.renderDefault(column.default, column)};`
+            );
+          }
+          if (diff.nullabilityChanged) {
+            statements.push(
+              `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} ${column.notNull ? 'SET' : 'DROP'} NOT NULL;`
+            );
+          }
+          if (diff.autoIncrementChanged) {
+            if (column.autoIncrement) {
+              const strategy = column.generated === 'always' ? 'ALWAYS' : 'BY DEFAULT';
+              statements.push(
+                `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} ADD GENERATED ${strategy} AS IDENTITY;`
+              );
+            } else {
+              statements.push(`ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP IDENTITY IF EXISTS;`);
+            }
+          }
+          return statements;
+        },
+        warning(table, column, actualColumn, diff) {
+          void table;
+          void column;
+          void actualColumn;
+          return diff.autoIncrementChanged
+            ? 'Altering identity properties may fail if an existing sequence is attached; verify generated column state.'
+            : undefined;
+        }
       }
-    }
-    const where = index.where ? ` WHERE ${index.where}` : '';
-    return `CREATE ${unique}INDEX IF NOT EXISTS ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)}${using} (${cols})${withClause}${where};`;
-  }
-
-  supportsPartialIndexes(): boolean {
-    return true;
-  }
+    })
+  });
 
-  protected renderReferenceSuffix(ref: ForeignKeyReference, _table: TableDef): string | undefined {
-    void _table;
-    if (ref.deferrable) {
-      return 'DEFERRABLE INITIALLY DEFERRED';
-    }
-    return undefined;
+/** Ergonomic facade; DDL rendering itself is pure composition. */
+export class PostgresSchemaDialect implements SchemaDialect {
+  private readonly delegate = createPostgresSchemaDialect();
+  readonly name = this.delegate.name;
+  readonly mutations = this.delegate.mutations;
+
+  quoteIdentifier(id: string): string { return this.delegate.quoteIdentifier(id); }
+  formatTableName(table: TableDef | DatabaseTable): string { return this.delegate.formatTableName(table); }
+  renderColumnType(column: ColumnDef): string { return this.delegate.renderColumnType(column); }
+  renderDefault(value: unknown, column: ColumnDef): string { return this.delegate.renderDefault(value, column); }
+  renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined {
+    return this.delegate.renderAutoIncrement(column, table);
   }
-
-  dropColumnSql(table: DatabaseTable, column: string): string[] {
-    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  renderReference(ref: Parameters<SchemaDialect['renderReference']>[0], table: TableDef): string {
+    return this.delegate.renderReference(ref, table);
   }
-
-  dropIndexSql(table: DatabaseTable, index: string): string[] {
-    const qualified = table.schema
-      ? `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(index)}`
-      : this.quoteIdentifier(index);
-    return [`DROP INDEX IF EXISTS ${qualified};`];
-  }
-
-  alterColumnSql(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[] {
-    void actualColumn;
-    const stmts: string[] = [];
-    const tableName = this.formatTableName(table);
-    const colName = this.quoteIdentifier(column.name);
-
-    if (diff.typeChanged) {
-      stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} TYPE ${this.renderColumnType(column)};`);
-    }
-    if (diff.defaultChanged) {
-      if (column.default === undefined) {
-        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} DROP DEFAULT;`);
-      } else {
-        stmts.push(
-          `ALTER TABLE ${tableName} ALTER COLUMN ${colName} SET DEFAULT ${this.renderDefault(column.default, column)};`
-        );
-      }
-    }
-    if (diff.nullabilityChanged) {
-      stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} ${column.notNull ? 'SET' : 'DROP'} NOT NULL;`);
-    }
-    if (diff.autoIncrementChanged) {
-      if (column.autoIncrement) {
-        const strategy = column.generated === 'always' ? 'ALWAYS' : 'BY DEFAULT';
-        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} ADD GENERATED ${strategy} AS IDENTITY;`);
-      } else {
-        stmts.push(`ALTER TABLE ${tableName} ALTER COLUMN ${colName} DROP IDENTITY IF EXISTS;`);
-      }
-    }
-    return stmts;
-  }
-
-  warnAlterColumn(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string | undefined {
-    void _table;
-    void _column;
-    void _actual;
-    if (diff.autoIncrementChanged) {
-      return 'Altering identity properties may fail if an existing sequence is attached; verify generated column state.';
-    }
-    return undefined;
+  renderIndex(table: TableDef, index: IndexDef): string { return this.delegate.renderIndex(table, index); }
+  renderTableOptions(table: TableDef): string | undefined { return this.delegate.renderTableOptions(table); }
+  supportsPartialIndexes(): boolean { return this.delegate.supportsPartialIndexes(); }
+  preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean {
+    return this.delegate.preferInlinePkAutoincrement(column, table, pk);
   }
 }
-

package/src/core/ddl/dialects/render-reference.test.ts

@@ -1,70 +1,50 @@
 import { describe, expect, it } from 'vitest';
-import { BaseSchemaDialect } from './base-schema-dialect.js';
+import { composeSchemaDialect } from '../schema-dialect-composer.js';
 import { PostgresSchemaDialect } from './postgres-schema-dialect.js';
-import { TableDef } from '../../../schema/table.js';
-import { ForeignKeyReference } from '../../../schema/column-types.js';
+import type { TableDef } from '../../../schema/table.js';
+import type { ForeignKeyReference } from '../../../schema/column-types.js';
 import { createLiteralFormatter } from '../sql-writing.js';
 
-class DummySchemaDialect extends BaseSchemaDialect {
-    readonly name = 'sqlite';
-    private readonly formatter = createLiteralFormatter({
-        booleanTrue: '1',
-        booleanFalse: '0',
-    });
-
-    get literalFormatter() {
-        return this.formatter;
-    }
-
-    quoteIdentifier(id: string): string {
-        return `"${id}"`;
-    }
-
-    renderColumnType(): string {
-        return 'INTEGER';
-    }
-
-    renderAutoIncrement(): string | undefined {
-        return undefined;
-    }
-
-    renderIndex(): string {
-        return 'CREATE INDEX dummy;';
-    }
-}
+const createDummySchemaDialect = () => composeSchemaDialect({
+  name: 'sqlite',
+  quoteIdentifier: id => `"${id}"`,
+  literalFormatter: createLiteralFormatter({ booleanTrue: '1', booleanFalse: '0' }),
+  renderColumnType: () => 'INTEGER',
+  renderAutoIncrement: () => undefined,
+  renderIndex: () => 'CREATE INDEX dummy;'
+});
 
 const table: TableDef = {
-    name: 'child',
-    columns: {},
-    relations: {},
+  name: 'child',
+  columns: {},
+  relations: {}
 };
 
 const deferrableReference: ForeignKeyReference = {
-    table: 'parent',
-    column: 'id',
-    deferrable: true,
-    onDelete: 'CASCADE',
-    onUpdate: 'NO ACTION',
+  table: 'parent',
+  column: 'id',
+  deferrable: true,
+  onDelete: 'CASCADE',
+  onUpdate: 'NO ACTION'
 };
 
 describe('renderReference deferrable handling', () => {
-    it('base dialect remains agnostic to deferrable flags', () => {
-        const dialect = new DummySchemaDialect();
-        const sql = dialect.renderReference(deferrableReference, table);
-        expect(sql).toContain('REFERENCES "parent"');
-        expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
-    });
-
-    it('Postgres dialect renders the deferrable clause', () => {
-        const dialect = new PostgresSchemaDialect();
-        const sql = dialect.renderReference(deferrableReference, table);
-        expect(sql).toContain('DEFERRABLE INITIALLY DEFERRED');
-    });
-
-    it('Postgres dialect skips the clause when the flag is missing', () => {
-        const dialect = new PostgresSchemaDialect();
-        const sql = dialect.renderReference({ table: 'parent', column: 'id' }, table);
-        expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
-    });
+  it('composed generic dialect remains agnostic to deferrable flags', () => {
+    const dialect = createDummySchemaDialect();
+    const sql = dialect.renderReference(deferrableReference, table);
+    expect(sql).toContain('REFERENCES "parent"');
+    expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
+  });
+
+  it('Postgres dialect renders the deferrable clause', () => {
+    const dialect = new PostgresSchemaDialect();
+    const sql = dialect.renderReference(deferrableReference, table);
+    expect(sql).toContain('DEFERRABLE INITIALLY DEFERRED');
+  });
+
+  it('Postgres dialect skips the clause when the flag is missing', () => {
+    const dialect = new PostgresSchemaDialect();
+    const sql = dialect.renderReference({ table: 'parent', column: 'id' }, table);
+    expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
+  });
 });
-