metal-orm 1.0.10 → 1.0.12

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

@@ -0,0 +1,109 @@
+import { BaseSchemaDialect } from './base-schema-dialect.js';
+import {
+  deriveIndexName,
+  renderIndexColumns,
+  DialectName,
+  formatLiteral,
+  escapeLiteral
+} from '../schema-generator.js';
+import { ColumnDef } from '../../../schema/column.js';
+import { IndexDef, TableDef } from '../../../schema/table.js';
+import { DatabaseTable } from '../schema-types.js';
+
+export class MySqlSchemaDialect extends BaseSchemaDialect {
+  name: DialectName = 'mysql';
+
+  quoteIdentifier(id: string): string {
+    return `\`${id}\``;
+  }
+
+  renderColumnType(column: ColumnDef): string {
+    switch (column.type) {
+      case 'INT':
+      case 'INTEGER':
+      case 'int':
+      case 'integer':
+        return 'INT';
+      case 'BIGINT':
+      case 'bigint':
+        return 'BIGINT';
+      case 'UUID':
+      case 'uuid':
+        return 'CHAR(36)';
+      case 'BOOLEAN':
+      case 'boolean':
+        return 'TINYINT(1)';
+      case 'JSON':
+      case 'json':
+        return 'JSON';
+      case 'DECIMAL':
+      case 'decimal':
+        return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : 'DECIMAL';
+      case 'FLOAT':
+      case 'float':
+        return column.args?.length ? `FLOAT(${column.args[0]})` : 'FLOAT';
+      case 'DOUBLE':
+      case 'double':
+        return 'DOUBLE';
+      case 'TIMESTAMPTZ':
+      case 'timestamptz':
+        return 'TIMESTAMP';
+      case 'TIMESTAMP':
+      case 'timestamp':
+        return 'TIMESTAMP';
+      case 'DATETIME':
+      case 'datetime':
+        return 'DATETIME';
+      case 'DATE':
+      case 'date':
+        return 'DATE';
+      case 'VARCHAR':
+      case 'varchar':
+        return column.args?.length ? `VARCHAR(${column.args[0]})` : 'VARCHAR(255)';
+      case 'TEXT':
+      case 'text':
+        return 'TEXT';
+      case 'ENUM':
+      case 'enum':
+        return column.args && Array.isArray(column.args) && column.args.length
+          ? `ENUM(${column.args.map((v: string) => `'${escapeLiteral(v)}'`).join(',')})`
+          : 'ENUM';
+      default:
+        return String(column.type).toUpperCase();
+    }
+  }
+
+  renderDefault(value: unknown): string {
+    return formatLiteral(value, this.name);
+  }
+
+  renderAutoIncrement(column: ColumnDef): string | undefined {
+    return column.autoIncrement ? 'AUTO_INCREMENT' : undefined;
+  }
+
+  renderIndex(table: TableDef, index: IndexDef): string {
+    if (index.where) {
+      throw new Error('MySQL 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 ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols});`;
+  }
+
+  renderTableOptions(table: TableDef): string | undefined {
+    const parts: string[] = [];
+    if (table.engine) parts.push(`ENGINE=${table.engine}`);
+    if (table.charset) parts.push(`DEFAULT CHARSET=${table.charset}`);
+    if (table.collation) parts.push(`COLLATE=${table.collation}`);
+    return parts.length ? parts.join(' ') : undefined;
+  }
+
+  dropColumnSql(table: DatabaseTable, column: string): string[] {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+
+  dropIndexSql(table: DatabaseTable, index: string): string[] {
+    return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
+  }
+}

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

@@ -0,0 +1,99 @@
+import { BaseSchemaDialect } from './base-schema-dialect.js';
+import {
+  deriveIndexName,
+  renderIndexColumns,
+  DialectName
+} from '../schema-generator.js';
+import { ColumnDef } from '../../../schema/column.js';
+import { IndexDef, TableDef } from '../../../schema/table.js';
+import { DatabaseTable } from '../schema-types.js';
+
+export class PostgresSchemaDialect extends BaseSchemaDialect {
+  name: DialectName = 'postgres';
+
+  quoteIdentifier(id: string): string {
+    return `"${id}"`;
+  }
+
+  renderColumnType(column: ColumnDef): string {
+    switch (column.type) {
+      case 'INT':
+      case 'INTEGER':
+      case 'int':
+      case 'integer':
+        return 'integer';
+      case 'BIGINT':
+      case 'bigint':
+        return 'bigint';
+      case 'UUID':
+      case 'uuid':
+        return 'uuid';
+      case 'BOOLEAN':
+      case 'boolean':
+        return 'boolean';
+      case 'JSON':
+      case 'json':
+        return 'jsonb';
+      case 'DECIMAL':
+      case 'decimal':
+        return column.args?.length ? `numeric(${column.args[0]}, ${column.args[1] ?? 0})` : 'numeric';
+      case 'FLOAT':
+      case 'float':
+      case 'DOUBLE':
+      case 'double':
+        return 'double precision';
+      case 'TIMESTAMPTZ':
+      case 'timestamptz':
+        return 'timestamptz';
+      case 'TIMESTAMP':
+      case 'timestamp':
+        return 'timestamp';
+      case 'DATE':
+      case 'date':
+        return 'date';
+      case 'DATETIME':
+      case 'datetime':
+        return 'timestamp';
+      case 'VARCHAR':
+      case 'varchar':
+        return column.args?.length ? `varchar(${column.args[0]})` : 'varchar';
+      case 'TEXT':
+      case 'text':
+        return 'text';
+      case 'ENUM':
+      case 'enum':
+        return 'text';
+      default:
+        return String(column.type).toLowerCase();
+    }
+  }
+
+  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);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? 'UNIQUE ' : '';
+    const where = index.where ? ` WHERE ${index.where}` : '';
+    return `CREATE ${unique}INDEX IF NOT EXISTS ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols})${where};`;
+  }
+
+  supportsPartialIndexes(): boolean {
+    return true;
+  }
+
+  dropColumnSql(table: DatabaseTable, column: string): string[] {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+
+  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};`];
+  }
+}

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

@@ -0,0 +1,103 @@
+import { BaseSchemaDialect } from './base-schema-dialect.js';
+import {
+  deriveIndexName,
+  renderIndexColumns,
+  DialectName,
+  formatLiteral,
+  resolvePrimaryKey
+} from '../schema-generator.js';
+import { ColumnDef } from '../../../schema/column.js';
+import { IndexDef, TableDef } from '../../../schema/table.js';
+import { DatabaseTable } from '../schema-types.js';
+
+export class SQLiteSchemaDialect extends BaseSchemaDialect {
+  name: DialectName = 'sqlite';
+
+  quoteIdentifier(id: string): string {
+    return `"${id}"`;
+  }
+
+  renderColumnType(column: ColumnDef): string {
+    switch (column.type) {
+      case 'INT':
+      case 'INTEGER':
+      case 'int':
+      case 'integer':
+      case 'BIGINT':
+      case 'bigint':
+        return 'INTEGER';
+      case 'BOOLEAN':
+      case 'boolean':
+        return 'INTEGER';
+      case 'DECIMAL':
+      case 'decimal':
+      case 'FLOAT':
+      case 'float':
+      case 'DOUBLE':
+      case 'double':
+        return 'REAL';
+      case 'DATE':
+      case 'date':
+      case 'DATETIME':
+      case 'datetime':
+      case 'TIMESTAMP':
+      case 'timestamp':
+      case 'TIMESTAMPTZ':
+      case 'timestamptz':
+        return 'TEXT';
+      case 'VARCHAR':
+      case 'varchar':
+      case 'TEXT':
+      case 'text':
+      case 'JSON':
+      case 'json':
+      case 'UUID':
+      case 'uuid':
+        return 'TEXT';
+      case 'ENUM':
+      case 'enum':
+        return 'TEXT';
+      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';
+    }
+    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 formatLiteral(value, this.name);
+  }
+
+  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[] {
+    return [];
+  }
+
+  dropIndexSql(_table: DatabaseTable, index: string): string[] {
+    return [`DROP INDEX IF EXISTS ${this.quoteIdentifier(index)};`];
+  }
+
+  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}).`;
+  }
+}

package/src/core/ddl/introspect/mssql.ts

@@ -0,0 +1,149 @@
+import { SchemaIntrospector, IntrospectOptions } from './types.js';
+import { queryRows, shouldIncludeTable } from './utils.js';
+import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
+import { DbExecutor } from '../../orm/db-executor.js';
+
+export const mssqlIntrospector: SchemaIntrospector = {
+  async introspect(executor: DbExecutor, options: IntrospectOptions): Promise<DatabaseSchema> {
+    const schema = options.schema;
+    const filterSchema = schema ? 'sch.name = @p1' : '1=1';
+    const params = schema ? [schema] : [];
+
+    const columnRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        c.name AS column_name,
+        ty.name AS data_type,
+        c.is_nullable,
+        c.is_identity,
+        object_definition(c.default_object_id) AS column_default
+      FROM sys.columns c
+      JOIN sys.tables t ON t.object_id = c.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      JOIN sys.types ty ON ty.user_type_id = c.user_type_id
+      WHERE t.is_ms_shipped = 0 AND ${filterSchema}
+      `,
+      params
+    );
+
+    const pkRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        c.name AS column_name,
+        ic.key_ordinal
+      FROM sys.indexes i
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 1 AND ${filterSchema}
+      ORDER BY ic.key_ordinal
+      `,
+      params
+    );
+
+    const pkMap = new Map<string, string[]>();
+    pkRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const list = pkMap.get(key) || [];
+      list.push(r.column_name);
+      pkMap.set(key, list);
+    });
+
+    const indexRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        i.name AS index_name,
+        i.is_unique,
+        i.has_filter,
+        i.filter_definition
+      FROM sys.indexes i
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 0 AND i.is_hypothetical = 0 AND ${filterSchema}
+      `,
+      params
+    );
+
+    const indexColsRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        i.name AS index_name,
+        c.name AS column_name,
+        ic.key_ordinal
+      FROM sys.index_columns ic
+      JOIN sys.indexes i ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 0 AND ${filterSchema}
+      ORDER BY ic.key_ordinal
+      `,
+      params
+    );
+
+    const indexColumnsMap = new Map<string, { column: string; order: number }[]>();
+    indexColsRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}.${r.index_name}`;
+      const list = indexColumnsMap.get(key) || [];
+      list.push({ column: r.column_name, order: r.key_ordinal });
+      indexColumnsMap.set(key, list);
+    });
+
+    const tablesByKey = new Map<string, DatabaseTable>();
+
+    columnRows.forEach(r => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const t = tablesByKey.get(key)!;
+      const column: DatabaseColumn = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === false || r.is_nullable === 0,
+        default: r.column_default ?? undefined,
+        autoIncrement: !!r.is_identity
+      };
+      t.columns.push(column);
+    });
+
+    indexRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const cols = (indexColumnsMap.get(`${r.table_schema}.${r.table_name}.${r.index_name}`) || [])
+        .sort((a, b) => a.order - b.order)
+        .map(c => ({ column: c.column }));
+      const idx: DatabaseIndex = {
+        name: r.index_name,
+        columns: cols,
+        unique: !!r.is_unique,
+        where: r.has_filter ? r.filter_definition : undefined
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+
+    return { tables: Array.from(tablesByKey.values()) };
+  }
+};

package/src/core/ddl/introspect/mysql.ts

@@ -0,0 +1,99 @@
+import { SchemaIntrospector, IntrospectOptions } from './types.js';
+import { queryRows, shouldIncludeTable } from './utils.js';
+import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
+import { DbExecutor } from '../../orm/db-executor.js';
+
+export const mysqlIntrospector: SchemaIntrospector = {
+  async introspect(executor: DbExecutor, options: IntrospectOptions): Promise<DatabaseSchema> {
+    const schema = options.schema;
+    const filterClause = schema ? 'table_schema = ?' : 'table_schema = database()';
+    const params = schema ? [schema] : [];
+
+    const columnRows = await queryRows(
+      executor,
+      `
+      SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default, extra
+      FROM information_schema.columns
+      WHERE ${filterClause}
+      ORDER BY table_name, ordinal_position
+      `,
+      params
+    );
+
+    const pkRows = await queryRows(
+      executor,
+      `
+      SELECT table_schema, table_name, column_name
+      FROM information_schema.key_column_usage
+      WHERE constraint_name = 'PRIMARY' AND ${filterClause}
+      ORDER BY ordinal_position
+      `,
+      params
+    );
+
+    const pkMap = new Map<string, string[]>();
+    pkRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const list = pkMap.get(key) || [];
+      list.push(r.column_name);
+      pkMap.set(key, list);
+    });
+
+    const indexRows = await queryRows(
+      executor,
+      `
+      SELECT
+        table_schema,
+        table_name,
+        index_name,
+        non_unique,
+        GROUP_CONCAT(column_name ORDER BY seq_in_index) AS cols
+      FROM information_schema.statistics
+      WHERE ${filterClause} AND index_name <> 'PRIMARY'
+      GROUP BY table_schema, table_name, index_name, non_unique
+      `,
+      params
+    );
+
+    const tablesByKey = new Map<string, DatabaseTable>();
+
+    columnRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const cols = tablesByKey.get(key)!;
+      const column: DatabaseColumn = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === 'NO',
+        default: r.column_default ?? undefined,
+        autoIncrement: typeof r.extra === 'string' && r.extra.includes('auto_increment')
+      };
+      cols.columns.push(column);
+    });
+
+    indexRows.forEach(r => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const cols = (typeof r.cols === 'string' ? r.cols.split(',') : []).map((c: string) => ({ column: c.trim() }));
+      const idx: DatabaseIndex = {
+        name: r.index_name,
+        columns: cols,
+        unique: r.non_unique === 0
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+
+    return { tables: Array.from(tablesByKey.values()) };
+  }
+};