metal-orm 1.1.26 → 1.1.28

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

@@ -1,131 +1,120 @@
-import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
-import { renderIndexColumns, resolvePrimaryKey, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef, 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';
-
-/** SQLite schema dialect implementation. */
-export class SQLiteSchemaDialect extends BaseSchemaDialect {
-  name: DialectName = 'sqlite';
-
-  private _literalFormatter = createLiteralFormatter({
-    booleanTrue: '1',
-    booleanFalse: '0',
-  });
-
-  get literalFormatter() {
-    return this._literalFormatter;
-  }
-
-  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);
+import {
+  createLiteralFormatter,
+  renderIndexColumns,
+  resolvePrimaryKey
+} from '../sql-writing.js';
+import {
+  composeSchemaDialect,
+  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({ booleanTrue: '1', booleanFalse: '0' });
+
+const renderSqliteColumnType = (
+  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':
+    case 'bigint':
+    case 'boolean': return 'INTEGER';
+    case 'decimal':
+    case 'float':
+    case 'double': return 'REAL';
+    case 'date':
+    case 'datetime':
+    case 'timestamp':
+    case 'timestamptz':
+    case 'varchar':
+    case 'text':
+    case 'json':
+    case 'uuid':
+    case 'enum': return 'TEXT';
+    case 'binary':
+    case 'varbinary':
+    case 'blob':
+    case 'bytea': return 'BLOB';
+    case 'halfvec': {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      return `float16[${dimensions}]`;
     }
-
-    const type = normalizeColumnType(column.type);
-    switch (type) {
-      case 'int':
-      case 'integer':
-      case 'bigint':
-        return 'INTEGER';
-      case 'boolean':
-        return 'INTEGER';
-      case 'decimal':
-      case 'float':
-      case 'double':
-        return 'REAL';
-      case 'date':
-      case 'datetime':
-      case 'timestamp':
-      case 'timestamptz':
-        return 'TEXT';
-      case 'varchar':
-      case 'text':
-      case 'json':
-      case 'uuid':
-      case 'enum':
-        return 'TEXT';
-      case 'binary':
-      case 'varbinary':
-      case 'blob':
-      case 'bytea':
-        return 'BLOB';
-      case 'halfvec': {
-        const dim = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
-        return `float16[${dim}]`;
-      }
-      case 'vector': {
-        const dim = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
-        const elemType = column.vectorOptions?.elementType === 'float16' ? 'float16' : 'float32';
-        return `${elemType}[${dim}]`;
-      }
-      default:
-        return 'TEXT';
-    }
-  }
-
-  renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined {
-    const pk = resolvePrimaryKey(table);
-    if (column.autoIncrement && pk.length === 1 && pk[0] === column.name) {
-      return 'PRIMARY KEY AUTOINCREMENT';
+    case 'vector': {
+      const dimensions = column.vectorOptions?.dimensions ?? column.args?.[0] ?? 3;
+      const elementType = column.vectorOptions?.elementType === 'float16' ? 'float16' : 'float32';
+      return `${elementType}[${dimensions}]`;
     }
-    return undefined;
-  }
-
-  preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean {
-    return !!(column.autoIncrement && pk.length === 1 && pk[0] === column.name);
-  }
-
-  renderDefault(value: unknown): string {
-    return this.literalFormatter.formatLiteral(value);
-  }
-
-  renderIndex(table: TableDef, index: IndexDef): string {
-    if (index.where) {
-      throw new Error('SQLite does not support partial/filtered indexes');
-    }
-    const name = index.name || deriveIndexName(table, index);
-    const cols = renderIndexColumns(this, index.columns);
-    const unique = index.unique ? 'UNIQUE ' : '';
-    return `CREATE ${unique}INDEX IF NOT EXISTS ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols});`;
-  }
-
-  dropColumnSql(_table: DatabaseTable, _column: string): string[] {
-    void _table;
-    void _column;
-    return [];
+    default: return 'TEXT';
   }
+};
+
+export const createSqliteSchemaDialect = (): SchemaDialect =>
+  composeSchemaDialect({
+    name: 'sqlite',
+    quoteIdentifier,
+    literalFormatter,
+    renderColumnType: renderSqliteColumnType,
+    renderAutoIncrement(column, table) {
+      const primaryKey = resolvePrimaryKey(table);
+      return column.autoIncrement && primaryKey.length === 1 && primaryKey[0] === column.name
+        ? 'PRIMARY KEY AUTOINCREMENT'
+        : undefined;
+    },
+    preferInlinePkAutoincrement: (column, table, primaryKey) => {
+      void table;
+      return !!(column.autoIncrement && primaryKey.length === 1 && primaryKey[0] === column.name);
+    },
+    renderIndex(table, index, services) {
+      const name = index.name || deriveIndexName(table, index);
+      const columns = renderIndexColumns(services, index.columns);
+      const unique = index.unique ? 'UNIQUE ' : '';
+      const where = index.where ? ` WHERE ${index.where}` : '';
+      return `CREATE ${unique}INDEX IF NOT EXISTS ${services.quoteIdentifier(name)} ON ${services.formatTableName(table)} (${columns})${where};`;
+    },
+    supportsPartialIndexes: true,
+    mutations: services => ({
+      dropTable: createStandardDropTableCapability(services),
+      dropIndex: {
+        compile: (_table, index) => [`DROP INDEX IF EXISTS ${services.quoteIdentifier(index)};`]
+      }
+    })
+  });
 
-  dropIndexSql(_table: DatabaseTable, index: string): string[] {
-    void _table;
-    return [`DROP INDEX IF EXISTS ${this.quoteIdentifier(index)};`];
-  }
+/** Ergonomic facade; DDL rendering itself is pure composition. */
+export class SQLiteSchemaDialect implements SchemaDialect {
+  private readonly delegate = createSqliteSchemaDialect();
+  readonly name = this.delegate.name;
+  readonly mutations = this.delegate.mutations;
 
-  warnDropColumn(table: DatabaseTable, column: string): string | undefined {
-    const key = table.schema ? `${table.schema}.${table.name}` : table.name;
-    return `Dropping columns on SQLite requires table rebuild (column ${column} on ${key}).`;
+  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);
   }
-
-  alterColumnSql(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string[] {
-    void _table;
-    void _column;
-    void _actual;
-    void _diff;
-    return [];
+  renderReference(ref: Parameters<SchemaDialect['renderReference']>[0], table: TableDef): string {
+    return this.delegate.renderReference(ref, table);
   }
-
-  warnAlterColumn(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string | undefined {
-    void _actual;
-    void _diff;
-    const key = table.schema ? `${table.schema}.${table.name}` : table.name;
-    return `SQLite ALTER COLUMN is not supported; rebuild table ${key} to change column ${column.name}.`;
+  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/schema-dialect-composer.ts

@@ -0,0 +1,129 @@
+import type { TableDef, IndexDef } from '../../schema/table.js';
+import type { ColumnDef, ForeignKeyReference } from '../../schema/column-types.js';
+import type { DatabaseTable } from './schema-types.js';
+import type {
+  DialectName,
+  SchemaDialect,
+  SchemaMutationCapabilities
+} from './schema-dialect.js';
+import {
+  formatLiteral,
+  quoteQualified,
+  type LiteralFormatter
+} from './sql-writing.js';
+
+export interface SchemaDialectServices {
+  readonly name: DialectName;
+  quoteIdentifier(id: string): string;
+  formatTableName(table: TableDef | DatabaseTable): string;
+  renderDefault(value: unknown, column: ColumnDef): string;
+}
+
+export interface SchemaDialectConfig {
+  name: DialectName;
+  quoteIdentifier(id: string): string;
+  literalFormatter: LiteralFormatter;
+
+  renderColumnType(column: ColumnDef, services: SchemaDialectServices): string;
+  renderAutoIncrement(
+    column: ColumnDef,
+    table: TableDef,
+    services: SchemaDialectServices
+  ): string | undefined;
+  renderIndex(
+    table: TableDef,
+    index: IndexDef,
+    services: SchemaDialectServices
+  ): string;
+
+  renderDefault?(
+    value: unknown,
+    column: ColumnDef,
+    services: SchemaDialectServices
+  ): string;
+  renderReferenceSuffix?(
+    ref: ForeignKeyReference,
+    table: TableDef,
+    services: SchemaDialectServices
+  ): string | undefined;
+  renderTableOptions?(
+    table: TableDef,
+    services: SchemaDialectServices
+  ): string | undefined;
+  supportsPartialIndexes?: boolean;
+  preferInlinePkAutoincrement?(
+    column: ColumnDef,
+    table: TableDef,
+    pk: string[],
+    services: SchemaDialectServices
+  ): boolean;
+  mutations?: (services: SchemaDialectServices) => SchemaMutationCapabilities;
+}
+
+/**
+ * Assembles a complete schema dialect from independent rendering functions and
+ * mutation capabilities. No inheritance participates in the DDL path.
+ */
+export const composeSchemaDialect = (config: SchemaDialectConfig): SchemaDialect => {
+  const quoteIdentifier = (id: string): string => config.quoteIdentifier(id);
+  const formatTableName = (table: TableDef | DatabaseTable): string =>
+    table.schema
+      ? `${quoteIdentifier(table.schema)}.${quoteIdentifier(table.name)}`
+      : quoteIdentifier(table.name);
+
+  let services!: SchemaDialectServices;
+  const renderDefault = (value: unknown, column: ColumnDef): string =>
+    config.renderDefault?.(value, column, services)
+      ?? formatLiteral(config.literalFormatter, value);
+
+  services = {
+    name: config.name,
+    quoteIdentifier,
+    formatTableName,
+    renderDefault
+  };
+
+  const mutations = config.mutations?.(services) ?? {};
+
+  return {
+    name: config.name,
+    mutations,
+    quoteIdentifier,
+    formatTableName,
+    renderColumnType: column => config.renderColumnType(column, services),
+    renderDefault,
+    renderAutoIncrement: (column, table) =>
+      config.renderAutoIncrement(column, table, services),
+    renderReference(ref, table) {
+      const parts = [
+        'REFERENCES',
+        quoteQualified({ quoteIdentifier }, ref.table),
+        `(${quoteIdentifier(ref.column)})`
+      ];
+      if (ref.onDelete) parts.push('ON DELETE', ref.onDelete);
+      if (ref.onUpdate) parts.push('ON UPDATE', ref.onUpdate);
+      const suffix = config.renderReferenceSuffix?.(ref, table, services);
+      if (suffix) parts.push(suffix);
+      return parts.join(' ');
+    },
+    renderIndex: (table, index) => config.renderIndex(table, index, services),
+    renderTableOptions: table => config.renderTableOptions?.(table, services),
+    supportsPartialIndexes: () => config.supportsPartialIndexes ?? false,
+    preferInlinePkAutoincrement: (column, table, pk) =>
+      config.preferInlinePkAutoincrement?.(column, table, pk, services) ?? false
+  };
+};
+
+export const createStandardDropTableCapability = (
+  services: SchemaDialectServices
+): NonNullable<SchemaMutationCapabilities['dropTable']> => ({
+  compile: table => [`DROP TABLE IF EXISTS ${services.formatTableName(table)};`]
+});
+
+export const createStandardDropColumnCapability = (
+  services: SchemaDialectServices
+): NonNullable<SchemaMutationCapabilities['dropColumn']> => ({
+  compile: (table, column) => [
+    `ALTER TABLE ${services.formatTableName(table)} DROP COLUMN ${services.quoteIdentifier(column)};`
+  ]
+});

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

@@ -10,47 +10,60 @@ export type DialectName =
   | 'mssql'
   | (string & {});
 
-/** Interface for schema dialect implementations that handle database-specific DDL operations. */
+export interface DropTableCapability {
+  compile(table: DatabaseTable): string[];
+  warning?(table: DatabaseTable): string | undefined;
+}
+
+export interface DropColumnCapability {
+  compile(table: DatabaseTable, column: string): string[];
+  warning?(table: DatabaseTable, column: string): string | undefined;
+}
+
+export interface DropIndexCapability {
+  compile(table: DatabaseTable, index: string): string[];
+  warning?(table: DatabaseTable, index: string): string | undefined;
+}
+
+export interface AlterColumnCapability {
+  compile(
+    table: TableDef,
+    column: ColumnDef,
+    actualColumn: DatabaseColumn,
+    diff: ColumnDiff
+  ): string[];
+  warning?(
+    table: TableDef,
+    column: ColumnDef,
+    actualColumn: DatabaseColumn,
+    diff: ColumnDiff
+  ): string | undefined;
+}
+
+/** Explicit DDL mutation capabilities supported by a schema dialect. */
+export interface SchemaMutationCapabilities {
+  dropTable?: DropTableCapability;
+  dropColumn?: DropColumnCapability;
+  dropIndex?: DropIndexCapability;
+  alterColumn?: AlterColumnCapability;
+}
+
+/** Structural contract for database-specific DDL rendering. */
 export interface SchemaDialect {
-  /** The name of the dialect. */
   readonly name: DialectName;
+  readonly mutations: SchemaMutationCapabilities;
 
-  /** Quotes an identifier for use in SQL. */
   quoteIdentifier(id: string): string;
-
-  /** Formats the table name for SQL. */
   formatTableName(table: TableDef | DatabaseTable): string;
 
-  /** Renders the column type for SQL. */
   renderColumnType(column: ColumnDef): string;
-  /** Renders the default value for SQL. */
   renderDefault(value: unknown, column: ColumnDef): string;
-  /** Renders the auto-increment clause for SQL. */
   renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
 
-  /** Renders a foreign key reference for SQL. */
   renderReference(ref: ForeignKeyReference, table: TableDef): string;
-  /** Renders an index for SQL. */
   renderIndex(table: TableDef, index: IndexDef): string;
-  /** Renders table options for SQL. */
   renderTableOptions(table: TableDef): string | undefined;
 
-  /** Checks if the dialect supports partial indexes. */
   supportsPartialIndexes(): boolean;
-  /** Checks if the dialect prefers inline primary key auto-increment. */
   preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean;
-
-  /** Generates SQL to drop a column. */
-  dropColumnSql?(table: DatabaseTable, column: string): string[];
-  /** Generates SQL to drop an index. */
-  dropIndexSql?(table: DatabaseTable, index: string): string[];
-  /** Generates SQL to drop a table. */
-  dropTableSql?(table: DatabaseTable): string[];
-  /** Returns a warning message for dropping a column. */
-  warnDropColumn?(table: DatabaseTable, column: string): string | undefined;
-  /** Generates SQL to alter a column. */
-  alterColumnSql?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[];
-  /** Returns a warning message for altering a column. */
-  warnAlterColumn?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string | undefined;
 }
-