uql-orm 0.9.5 → 0.10.2

package/dist/migrate/schemaGenerator.js

@@ -0,0 +1,693 @@
+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