uql-orm 0.9.3 → 0.9.5

package/dist/migrate/schemaGenerator.js

@@ -1,693 +0,0 @@
-import { AbstractSqlDialect } from '../dialect/index.js';
-import { getMeta } from '../entity/index.js';
-import { areTypesEqual, canonicalToSql, fieldOptionsToCanonical, isVectorCategory, sqlToCanonical, } from '../schema/canonicalType.js';
-import { SchemaASTBuilder } from '../schema/schemaASTBuilder.js';
-import { escapeSqlId, getKeys, isAutoIncrement } from '../util/index.js';
-import { formatDefaultValue } from './builder/expressions.js';
-/** Maps UQL distance metric names to inline DDL keywords (e.g. MariaDB `DISTANCE=euclidean`). */
-const INLINE_VECTOR_DISTANCE_MAP = { cosine: 'cosine', l2: 'euclidean' };
-/**
- * Unified SQL schema generator.
- * Parameterized by dialect to handle Postgres, MySQL, MariaDB, and SQLite.
- */
-export class SqlSchemaGenerator {
-    dialect;
-    defaultForeignKeyAction;
-    constructor(dialect, defaultForeignKeyAction = 'NO ACTION') {
-        this.dialect = dialect;
-        this.defaultForeignKeyAction = defaultForeignKeyAction;
-    }
-    get namingStrategy() {
-        return this.dialect.namingStrategy;
-    }
-    get features() {
-        return this.dialect.features;
-    }
-    resolveTableName(entity, meta) {
-        return this.dialect.resolveTableName(entity, meta);
-    }
-    resolveColumnName(key, field) {
-        return this.dialect.resolveColumnName(key, field);
-    }
-    /**
-     * Escape an identifier (table name, column name, etc.)
-     */
-    escapeId(identifier) {
-        return escapeSqlId(identifier, this.dialect.quoteChar);
-    }
-    /**
-     * Primary key type for auto-increment integer IDs
-     */
-    get serialPrimaryKeyType() {
-        return this.dialect.serialPrimaryKey;
-    }
-    // ============================================================================
-    // CanonicalType Integration (Unified Type System)
-    // ============================================================================
-    /**
-     * Convert FieldOptions to CanonicalType using the unified type system.
-     */
-    getCanonicalType(field, fieldType) {
-        return fieldOptionsToCanonical(field, fieldType);
-    }
-    /**
-     * Convert CanonicalType to SQL type string for this dialect.
-     * Also handles legacy string types for backward compatibility.
-     */
-    canonicalTypeToSql(type) {
-        // Handle legacy string types
-        if (typeof type === 'string') {
-            return type;
-        }
-        return canonicalToSql(type, this.dialect);
-    }
-    // ============================================================================
-    // SchemaGenerator Implementation
-    // ============================================================================
-    generateCreateTable(entity, options = {}) {
-        const builder = new SchemaASTBuilder(this.dialect.namingStrategy);
-        const ast = builder.fromEntities([entity]);
-        const tableNode = ast.getTables()[0];
-        return this.generateCreateTableFromNode(tableNode, options);
-    }
-    generateDropTable(entity) {
-        const meta = getMeta(entity);
-        const tableName = this.dialect.resolveTableName(entity, meta);
-        return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;
-    }
-    generateAlterTable(diff) {
-        const statements = [];
-        const tableName = this.escapeId(diff.tableName);
-        // Add new columns
-        if (diff.columnsToAdd?.length) {
-            for (const column of diff.columnsToAdd) {
-                const colDef = this.generateColumnDefinitionFromSchema(column);
-                statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${colDef};`);
-            }
-        }
-        // Alter existing columns
-        if (diff.columnsToAlter?.length) {
-            for (const { to } of diff.columnsToAlter) {
-                const colDef = this.generateColumnDefinitionFromSchema(to);
-                const colStatements = this.generateAlterColumnStatements(diff.tableName, to, colDef);
-                statements.push(...colStatements);
-            }
-        }
-        // Drop columns
-        if (diff.columnsToDrop?.length) {
-            for (const columnName of diff.columnsToDrop) {
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);
-            }
-        }
-        // Add indexes
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd) {
-                statements.push(this.generateCreateIndex(diff.tableName, index));
-            }
-        }
-        // Drop indexes
-        if (diff.indexesToDrop?.length) {
-            for (const indexName of diff.indexesToDrop) {
-                statements.push(this.generateDropIndex(diff.tableName, indexName));
-            }
-        }
-        return statements;
-    }
-    generateAlterTableDown(diff) {
-        const statements = [];
-        const tableName = this.escapeId(diff.tableName);
-        // Reverse column additions by dropping them
-        if (diff.columnsToAdd?.length) {
-            for (const column of diff.columnsToAdd) {
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
-            }
-        }
-        // Reverse column alterations by restoring original schema
-        if (diff.columnsToAlter?.length) {
-            for (const { from } of diff.columnsToAlter) {
-                const colDef = this.generateColumnDefinitionFromSchema(from, { includePrimaryKey: false });
-                const colStatements = this.generateAlterColumnStatements(diff.tableName, from, colDef);
-                statements.push(...colStatements);
-            }
-        }
-        // Reverse index additions by dropping them
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd) {
-                statements.push(this.generateDropIndex(diff.tableName, index.name));
-            }
-        }
-        if (diff.columnsToDrop?.length || diff.indexesToDrop?.length) {
-            statements.push(`-- TODO: Manual reversal needed for dropped columns/indexes`);
-        }
-        return statements;
-    }
-    generateCreateIndex(tableName, index, options = {}) {
-        const unique = index.unique ? 'UNIQUE ' : '';
-        const ifNotExists = (options.ifNotExists ?? this.features.indexIfNotExists) ? 'IF NOT EXISTS ' : '';
-        const opsClassMap = this.dialect.vectorOpsClass;
-        const hasOpsClass = opsClassMap && (index.type === 'hnsw' || index.type === 'ivfflat');
-        // For pgvector indexes: append operator class to the column
-        const columns = index.columns
-            .map((c) => {
-            const escaped = this.escapeId(c);
-            if (hasOpsClass && index.distance) {
-                const opsClass = opsClassMap[index.distance];
-                return opsClass ? `${escaped} ${opsClass}` : escaped;
-            }
-            return escaped;
-        })
-            .join(', ');
-        const using = index.type ? ` USING ${index.type}` : '';
-        // Build WITH params for vector indexes with operator class support
-        let withClause = '';
-        if (hasOpsClass) {
-            const withParams = [];
-            if (index.m !== undefined)
-                withParams.push(`m = ${index.m}`);
-            if (index.efConstruction !== undefined)
-                withParams.push(`ef_construction = ${index.efConstruction}`);
-            if (index.lists !== undefined)
-                withParams.push(`lists = ${index.lists}`);
-            withClause = withParams.length > 0 ? ` WITH (${withParams.join(', ')})` : '';
-        }
-        return `CREATE ${unique}INDEX ${ifNotExists}${this.escapeId(index.name)} ON ${this.escapeId(tableName)}${using} (${columns})${withClause};`;
-    }
-    generateDropIndex(tableName, indexName) {
-        if (this.dialect.dropIndexSyntax === 'on-table') {
-            return `DROP INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)};`;
-        }
-        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
-    }
-    /**
-     * Generate column definition from a ColumnSchema object
-     */
-    generateColumnDefinitionFromSchema(column, options = {}) {
-        const { includePrimaryKey = true, includeUnique = true } = options;
-        let type = column.type;
-        if (!type.includes('(')) {
-            if (column.precision !== undefined) {
-                if (column.scale !== undefined) {
-                    type += `(${column.precision}, ${column.scale})`;
-                }
-                else {
-                    type += `(${column.precision})`;
-                }
-            }
-            else if (column.length !== undefined) {
-                type += `(${column.length})`;
-            }
-        }
-        if (!includePrimaryKey) {
-            type = type.replace(/\s+PRIMARY\s+KEY/i, '');
-        }
-        let definition = `${this.escapeId(column.name)} ${type}`;
-        if (includePrimaryKey && column.isPrimaryKey && !type.includes('PRIMARY KEY')) {
-            definition += ' PRIMARY KEY';
-        }
-        if (!column.nullable && !column.isPrimaryKey) {
-            definition += ' NOT NULL';
-        }
-        if (includeUnique && column.isUnique && !column.isPrimaryKey) {
-            definition += ' UNIQUE';
-        }
-        if (column.defaultValue !== undefined) {
-            definition += ` DEFAULT ${this.formatDefaultValue(column.defaultValue)}`;
-        }
-        if (column.comment) {
-            definition += this.generateColumnComment(column.name, column.comment);
-        }
-        return definition;
-    }
-    getSqlType(field, fieldType) {
-        // If field has a reference, inherit type from the target primary key
-        if (field.references) {
-            const refEntity = field.references();
-            const refMeta = getMeta(refEntity);
-            const refIdField = refMeta.fields[refMeta.id];
-            return this.getSqlType({ ...refIdField, references: undefined, isId: undefined, autoIncrement: false }, refIdField.type);
-        }
-        // Get canonical type and convert to SQL
-        const canonical = this.getCanonicalType(field, fieldType);
-        // Special case for serial primary keys
-        if (isAutoIncrement(field, field.isId === true)) {
-            return this.dialect.serialPrimaryKey;
-        }
-        return this.canonicalTypeToSql(canonical);
-    }
-    /**
-     * Get the boolean type for this database
-     */
-    getBooleanType() {
-        return this.canonicalTypeToSql({ category: 'boolean' });
-    }
-    /**
-     * Generate ALTER COLUMN statements (database-specific)
-     */
-    generateAlterColumnStatements(tableName, column, newDefinition) {
-        const table = this.escapeId(tableName);
-        const colName = this.escapeId(column.name);
-        if (this.dialect.alterColumnSyntax === 'none') {
-            throw new Error(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
-                `This database does not support ALTER COLUMN.`);
-        }
-        if (this.dialect.alterColumnStrategy === 'separate-clauses') {
-            const statements = [];
-            // Separate ALTER COLUMN clauses for different changes (Postgres)
-            statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} TYPE ${column.type};`);
-            if (column.nullable) {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} DROP NOT NULL;`);
-            }
-            else {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} SET NOT NULL;`);
-            }
-            if (column.defaultValue !== undefined) {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} SET DEFAULT ${this.formatDefaultValue(column.defaultValue)};`);
-            }
-            else {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} DROP DEFAULT;`);
-            }
-            return statements;
-        }
-        return [`ALTER TABLE ${table} ${this.dialect.alterColumnSyntax} ${newDefinition};`];
-    }
-    /**
-     * Get table options (e.g., ENGINE for MySQL)
-     */
-    getTableOptions(_meta) {
-        return this.dialect.tableOptions ? ` ${this.dialect.tableOptions}` : '';
-    }
-    /**
-     * Generate column comment clause (if supported)
-     */
-    generateColumnComment(columnName, comment) {
-        if (this.features.columnComment) {
-            const escapedComment = comment.replace(/'/g, "''");
-            return ` COMMENT '${escapedComment}'`;
-        }
-        return '';
-    }
-    /**
-     * Format a default value for SQL
-     */
-    formatDefaultValue(value) {
-        if (this.dialect.booleanLiteral === 'integer' && typeof value === 'boolean') {
-            return value ? '1' : '0';
-        }
-        return formatDefaultValue(value);
-    }
-    /**
-     * Compare an entity with a database table node and return the differences.
-     */
-    diffSchema(entity, currentTable) {
-        const meta = getMeta(entity);
-        if (!currentTable) {
-            return {
-                tableName: this.dialect.resolveTableName(entity, meta),
-                type: 'create',
-            };
-        }
-        const columnsToAdd = [];
-        const columnsToAlter = [];
-        const columnsToDrop = [];
-        const currentColumns = new Map(currentTable.columns);
-        const fieldKeys = getKeys(meta.fields);
-        for (const key of fieldKeys) {
-            const field = meta.fields[key];
-            if (!field || field.virtual)
-                continue;
-            const columnName = this.dialect.resolveColumnName(key, field);
-            const currentColumn = currentColumns.get(columnName);
-            if (!currentColumn) {
-                columnsToAdd.push(this.fieldToColumnSchema(key, field, meta));
-            }
-            else {
-                const desiredColumn = this.fieldToColumnSchema(key, field, meta);
-                const currentColumnSchema = this.columnNodeToSchema(currentColumn);
-                if (this.columnsNeedAlteration(currentColumnSchema, desiredColumn)) {
-                    columnsToAlter.push({ from: currentColumnSchema, to: desiredColumn });
-                }
-            }
-            currentColumns.delete(columnName);
-        }
-        for (const [name] of currentColumns) {
-            columnsToDrop.push(name);
-        }
-        if (columnsToAdd.length === 0 && columnsToAlter.length === 0 && columnsToDrop.length === 0) {
-            return undefined;
-        }
-        return {
-            tableName: this.dialect.resolveTableName(entity, meta),
-            type: 'alter',
-            columnsToAdd: columnsToAdd.length > 0 ? columnsToAdd : undefined,
-            columnsToAlter: columnsToAlter.length > 0 ? columnsToAlter : undefined,
-            columnsToDrop: columnsToDrop.length > 0 ? columnsToDrop : undefined,
-        };
-    }
-    columnNodeToSchema(col) {
-        return {
-            name: col.name,
-            type: this.canonicalTypeToSql(col.type),
-            nullable: col.nullable,
-            defaultValue: col.defaultValue,
-            isPrimaryKey: col.isPrimaryKey,
-            isAutoIncrement: col.isAutoIncrement,
-            isUnique: col.isUnique,
-            comment: col.comment,
-        };
-    }
-    /**
-     * Convert field options to ColumnSchema
-     */
-    fieldToColumnSchema(fieldKey, field, meta) {
-        const isPrimaryKey = field.isId === true && meta.id === fieldKey;
-        return {
-            name: this.dialect.resolveColumnName(fieldKey, field),
-            type: this.getSqlType(field, field.type),
-            nullable: field.nullable ?? !isPrimaryKey,
-            defaultValue: field.defaultValue,
-            isPrimaryKey,
-            isAutoIncrement: isAutoIncrement(field, isPrimaryKey),
-            isUnique: field.unique ?? false,
-            length: field.length,
-            precision: field.precision,
-            scale: field.scale,
-            comment: field.comment,
-        };
-    }
-    /**
-     * Check if two columns differ enough to require alteration
-     */
-    columnsNeedAlteration(current, desired) {
-        if (current.isPrimaryKey && desired.isPrimaryKey) {
-            return false;
-        }
-        if (current.isPrimaryKey !== desired.isPrimaryKey)
-            return true;
-        if (current.nullable !== desired.nullable)
-            return true;
-        if (current.isUnique !== desired.isUnique)
-            return true;
-        if (!this.isTypeEqual(current, desired))
-            return true;
-        if (!this.isDefaultValueEqual(current.defaultValue, desired.defaultValue))
-            return true;
-        return false;
-    }
-    /**
-     * Compare two column types for equality using the canonical type system
-     */
-    isTypeEqual(current, desired) {
-        const typeA = sqlToCanonical(current.type);
-        const typeB = sqlToCanonical(desired.type);
-        return areTypesEqual(typeA, typeB);
-    }
-    /**
-     * Compare two default values for equality
-     */
-    isDefaultValueEqual(current, desired) {
-        if (current === desired)
-            return true;
-        if (current === undefined || desired === undefined)
-            return current === desired;
-        const normalize = (val) => {
-            if (val === null)
-                return 'null';
-            if (typeof val === 'string') {
-                let s = val.replace(/::[a-z_]+(\s+[a-z_]+)*(\[\])?$/i, '');
-                s = s.replace(/^'(.*)'$/, '$1');
-                if (s.toLowerCase() === 'null')
-                    return 'null';
-                return s;
-            }
-            return typeof val === 'object' ? JSON.stringify(val) : String(val);
-        };
-        return normalize(current) === normalize(desired);
-    }
-    // ============================================================================
-    // SchemaAST Support Methods
-    // ============================================================================
-    generateCreateTableFromNode(table, options = {}) {
-        const columns = [];
-        const constraints = [];
-        for (const col of table.columns.values()) {
-            const colDef = this.generateColumnFromNode(col);
-            columns.push(colDef);
-        }
-        if (table.primaryKey.length > 1) {
-            const pkCols = table.primaryKey.map((c) => this.escapeId(c.name)).join(', ');
-            constraints.push(`PRIMARY KEY (${pkCols})`);
-        }
-        for (const rel of table.outgoingRelations) {
-            if (rel.from.columns.length > 0) {
-                const fromCols = rel.from.columns.map((c) => this.escapeId(c.name)).join(', ');
-                const toCols = rel.to.columns.map((c) => this.escapeId(c.name)).join(', ');
-                const constraintName = rel.name ? `CONSTRAINT ${this.escapeId(rel.name)} ` : '';
-                constraints.push(`${constraintName}FOREIGN KEY (${fromCols}) REFERENCES ${this.escapeId(rel.to.table.name)} (${toCols})` +
-                    ` ON DELETE ${rel.onDelete ?? this.defaultForeignKeyAction} ON UPDATE ${rel.onUpdate ?? this.defaultForeignKeyAction}`);
-            }
-        }
-        const ifNotExists = options.ifNotExists && this.features.ifNotExists ? 'IF NOT EXISTS ' : '';
-        let createSql = `CREATE TABLE ${ifNotExists}${this.escapeId(table.name)} (\n`;
-        createSql += columns.map((col) => `  ${col}`).join(',\n');
-        if (constraints.length > 0) {
-            createSql += ',\n';
-            createSql += constraints.map((c) => `  ${c}`).join(',\n');
-        }
-        const isInlineVectorIdx = this.features.vectorIndexStyle === 'inline';
-        const vectorIndexes = isInlineVectorIdx ? table.indexes.filter((idx) => idx.type === 'vector') : [];
-        const regularIndexes = isInlineVectorIdx ? table.indexes.filter((idx) => idx.type !== 'vector') : table.indexes;
-        if (vectorIndexes.length > 0) {
-            createSql += ',\n';
-            createSql += vectorIndexes.map((idx) => `  ${this.generateInlineVectorIndex(idx)}`).join(',\n');
-        }
-        createSql += '\n)';
-        if (this.dialect.tableOptions) {
-            createSql += ` ${this.dialect.tableOptions}`;
-        }
-        createSql += ';';
-        const statements = [];
-        if (this.dialect.vectorExtension) {
-            const hasVectorCol = [...table.columns.values()].some((c) => isVectorCategory(c.type.category));
-            if (hasVectorCol) {
-                statements.push(`CREATE EXTENSION IF NOT EXISTS ${this.dialect.vectorExtension};`);
-            }
-        }
-        statements.push(createSql);
-        for (const idx of regularIndexes) {
-            statements.push(this.generateCreateIndexFromNode(idx));
-        }
-        return statements;
-    }
-    /**
-     * Generate a column definition from a ColumnNode.
-     */
-    generateColumnFromNode(col) {
-        const colName = this.escapeId(col.name);
-        let sqlType = this.canonicalTypeToSql(col.type);
-        if (col.isPrimaryKey && col.isAutoIncrement) {
-            sqlType = this.serialPrimaryKeyType;
-        }
-        let def = `${colName} ${sqlType}`;
-        if (!col.nullable && !col.isPrimaryKey) {
-            def += ' NOT NULL';
-        }
-        if (col.isPrimaryKey && col.table.primaryKey.length === 1 && !sqlType.includes('PRIMARY KEY')) {
-            def += ' PRIMARY KEY';
-        }
-        if (col.isUnique && !col.isPrimaryKey) {
-            def += ' UNIQUE';
-        }
-        if (col.defaultValue !== undefined) {
-            def += ` DEFAULT ${this.formatDefaultValue(col.defaultValue)}`;
-        }
-        if (col.comment) {
-            def += this.generateColumnComment(col.name, col.comment);
-        }
-        return def;
-    }
-    /**
-     * Generate an inline VECTOR INDEX clause for use inside CREATE TABLE.
-     * Syntax: `VECTOR INDEX (col) M=n DISTANCE=metric`
-     */
-    generateInlineVectorIndex(index) {
-        const columns = index.columns.map((c) => this.escapeId(c.name)).join(', ');
-        let clause = `VECTOR INDEX (${columns})`;
-        if (index.m !== undefined) {
-            clause += ` M=${index.m}`;
-        }
-        if (index.distance) {
-            const metric = INLINE_VECTOR_DISTANCE_MAP[index.distance] ?? 'euclidean';
-            clause += ` DISTANCE=${metric}`;
-        }
-        return clause;
-    }
-    /**
-     * Generate CREATE INDEX SQL from an IndexNode.
-     * Delegates to `generateCreateIndex` for unified SQL assembly.
-     */
-    generateCreateIndexFromNode(index, options = { ifNotExists: false }) {
-        return this.generateCreateIndex(index.table.name, {
-            name: index.name,
-            columns: index.columns.map((c) => c.name),
-            unique: index.unique,
-            type: index.type,
-            distance: index.distance,
-            m: index.m,
-            efConstruction: index.efConstruction,
-            lists: index.lists,
-        }, options);
-    }
-    /**
-     * Generate DROP TABLE SQL from a TableNode.
-     */
-    generateDropTableFromNode(table, options = {}) {
-        const ifExists = options.ifExists ? 'IF EXISTS ' : '';
-        return `DROP TABLE ${ifExists}${this.escapeId(table.name)};`;
-    }
-    // ============================================================================
-    // Phase 3: Builder Operation Methods (Moved forward for unification)
-    // ============================================================================
-    generateCreateTableFromDefinition(table, options = {}) {
-        const tableNode = this.tableDefinitionToNode(table);
-        return this.generateCreateTableFromNode(tableNode, options);
-    }
-    generateDropTableSql(tableName, options) {
-        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
-        // Use dialect-specific cascade support from config
-        const cascade = options?.cascade && this.features.dropTableCascade ? ' CASCADE' : '';
-        return `DROP TABLE ${ifExists}${this.escapeId(tableName)}${cascade};`;
-    }
-    generateRenameTableSql(oldName, newName) {
-        if (this.dialect.renameTableSyntax === 'rename-table') {
-            return `RENAME TABLE ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
-        }
-        return `ALTER TABLE ${this.escapeId(oldName)} RENAME TO ${this.escapeId(newName)};`;
-    }
-    generateAddColumnSql(tableName, column) {
-        const colSql = this.generateColumnFromNode(this.fullColumnDefinitionToNode(column, tableName));
-        return `ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${colSql};`;
-    }
-    generateAlterColumnSql(tableName, columnName, column) {
-        const colSql = this.generateColumnFromNode(this.fullColumnDefinitionToNode(column, tableName));
-        return this.generateAlterColumnStatements(tableName, { name: columnName, type: '' }, colSql).join('\n');
-    }
-    generateDropColumnSql(tableName, columnName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)};`;
-    }
-    generateRenameColumnSql(tableName, oldName, newName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} RENAME COLUMN ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
-    }
-    generateCreateIndexSql(tableName, index) {
-        return this.generateCreateIndex(tableName, index);
-    }
-    generateDropIndexSql(tableName, indexName) {
-        return this.generateDropIndex(tableName, indexName);
-    }
-    generateAddForeignKeySql(tableName, foreignKey) {
-        const fkCols = foreignKey.columns.map((c) => this.escapeId(c)).join(', ');
-        const refCols = foreignKey.referencesColumns.map((c) => this.escapeId(c)).join(', ');
-        const constraintName = foreignKey.name
-            ? this.escapeId(foreignKey.name)
-            : this.escapeId(`fk_${tableName}_${foreignKey.columns.join('_')}`);
-        if (!this.features.foreignKeyAlter) {
-            throw new Error(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
-        }
-        return (`ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${constraintName} ` +
-            `FOREIGN KEY (${fkCols}) REFERENCES ${this.escapeId(foreignKey.referencesTable)} (${refCols}) ` +
-            `ON DELETE ${foreignKey.onDelete ?? this.defaultForeignKeyAction} ON UPDATE ${foreignKey.onUpdate ?? this.defaultForeignKeyAction};`);
-    }
-    generateDropForeignKeySql(tableName, constraintName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} ${this.dialect.dropForeignKeySyntax} ${this.escapeId(constraintName)};`;
-    }
-    tableDefinitionToNode(def) {
-        const columns = new Map();
-        const pkNodes = [];
-        const table = {
-            name: def.name,
-            columns,
-            primaryKey: [], // placeholder
-            indexes: [],
-            schema: { tables: new Map(), relationships: [], indexes: [] },
-            incomingRelations: [],
-            outgoingRelations: [],
-            comment: def.comment,
-        };
-        for (const colDef of def.columns) {
-            const node = this.fullColumnDefinitionToNode(colDef, def.name);
-            node.table = table;
-            columns.set(node.name, node);
-            if (node.isPrimaryKey) {
-                pkNodes.push(node);
-            }
-        }
-        const finalPrimaryKey = def.primaryKey
-            ? def.primaryKey.map((name) => columns.get(name)).filter((c) => c !== undefined)
-            : pkNodes;
-        table.primaryKey = finalPrimaryKey;
-        for (const idxDef of def.indexes) {
-            const indexNode = {
-                name: idxDef.name,
-                table,
-                columns: idxDef.columns.map((name) => columns.get(name)).filter((c) => c !== undefined),
-                unique: idxDef.unique,
-            };
-            table.indexes.push(indexNode);
-        }
-        for (const fkDef of def.foreignKeys) {
-            const relNode = {
-                name: fkDef.name ?? `fk_${def.name}_${fkDef.columns.join('_')}`,
-                type: 'ManyToOne', // Builder default
-                from: {
-                    table,
-                    columns: fkDef.columns.map((name) => columns.get(name)).filter((c) => c !== undefined),
-                },
-                to: {
-                    table: { name: fkDef.referencesTable },
-                    columns: fkDef.referencesColumns.map((name) => ({ name })),
-                },
-                onDelete: fkDef.onDelete,
-                onUpdate: fkDef.onUpdate,
-            };
-            table.outgoingRelations.push(relNode);
-        }
-        return table;
-    }
-    fullColumnDefinitionToNode(col, tableName) {
-        return {
-            name: col.name,
-            type: col.type,
-            nullable: col.nullable,
-            defaultValue: col.defaultValue,
-            isPrimaryKey: col.primaryKey,
-            isAutoIncrement: col.autoIncrement,
-            isUnique: col.unique,
-            comment: col.comment,
-            table: { name: tableName },
-            referencedBy: [],
-            references: col.foreignKey
-                ? {
-                    name: `fk_${tableName}_${col.name}`,
-                    type: 'ManyToOne',
-                    from: { table: { name: tableName }, columns: [] },
-                    to: {
-                        table: { name: col.foreignKey.table },
-                        columns: col.foreignKey.columns.map((name) => ({ name })),
-                    },
-                    onDelete: col.foreignKey.onDelete,
-                    onUpdate: col.foreignKey.onUpdate,
-                }
-                : undefined,
-        };
-    }
-}
-/**
- * Synchronous factory for SQL schema generators only.
- * For MongoDB, use `createSchemaGeneratorAsync` from `./schemaGeneratorAsync.js` so the optional `mongodb` peer is not loaded at import time.
- */
-export function createSchemaGenerator(dialect, namingStrategy, defaultForeignKeyAction) {
-    if (!(dialect instanceof AbstractSqlDialect)) {
-        return undefined;
-    }
-    return new SqlSchemaGenerator(dialect, defaultForeignKeyAction);
-}
-//# sourceMappingURL=schemaGenerator.js.map