@uql/core 1.0.12 → 3.1.0

package/dist/migrate/migrator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/migrate/migrator.test.js

@@ -0,0 +1,106 @@
+import { __decorate, __metadata } from "tslib";
+import { beforeEach, describe, expect, it, jest } from 'bun:test';
+import { Entity, Field, Id } from '../entity/index.js';
+import { Migrator } from './migrator.js';
+let SyncUser = class SyncUser {
+    id;
+    name;
+};
+__decorate([
+    Id(),
+    __metadata("design:type", Number)
+], SyncUser.prototype, "id", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SyncUser.prototype, "name", void 0);
+SyncUser = __decorate([
+    Entity()
+], SyncUser);
+let SyncProfile = class SyncProfile {
+    id;
+    bio;
+    userId;
+};
+__decorate([
+    Id(),
+    __metadata("design:type", Number)
+], SyncProfile.prototype, "id", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], SyncProfile.prototype, "bio", void 0);
+__decorate([
+    Field({ reference: () => SyncUser }),
+    __metadata("design:type", Number)
+], SyncProfile.prototype, "userId", void 0);
+SyncProfile = __decorate([
+    Entity()
+], SyncProfile);
+describe('Migrator autoSync Integration', () => {
+    let migrator;
+    let pool;
+    beforeEach(() => {
+        // Mock pool and querier for testing
+        const querier = {
+            run: jest.fn().mockResolvedValue({}),
+            all: jest.fn().mockResolvedValue([]),
+            beginTransaction: jest.fn().mockResolvedValue(undefined),
+            commitTransaction: jest.fn().mockResolvedValue(undefined),
+            rollbackTransaction: jest.fn().mockResolvedValue(undefined),
+            release: jest.fn().mockResolvedValue(undefined),
+            dialect: {
+                escapeIdChar: '"',
+                placeholder: jest.fn().mockReturnValue('?'),
+            },
+        };
+        pool = {
+            getQuerier: jest.fn().mockResolvedValue(querier),
+            dialect: 'postgres',
+        };
+        migrator = new Migrator(pool, {
+            entities: [SyncUser, SyncProfile],
+        });
+    });
+    it('should generate create statements for new tables', async () => {
+        // Mock introspector to return nothing
+        const introspector = {
+            getTableSchema: jest.fn().mockResolvedValue(undefined),
+            getTableNames: jest.fn().mockResolvedValue([]),
+            tableExists: jest.fn().mockResolvedValue(false),
+        };
+        migrator.schemaIntrospector = introspector;
+        await migrator.autoSync({ logging: true });
+        const querier = (await pool.getQuerier());
+        expect(querier.run).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE "SyncUser"'));
+        expect(querier.run).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE "SyncProfile"'));
+    });
+    it('should generate alter statements for missing columns', async () => {
+        // Mock introspector to return existing table with one column missing
+        const introspector = {
+            getTableSchema: jest.fn().mockImplementation((name) => {
+                if (name === 'SyncUser') {
+                    return Promise.resolve({
+                        name: 'SyncUser',
+                        columns: [
+                            {
+                                name: 'id',
+                                type: 'INTEGER',
+                                nullable: false,
+                                isPrimaryKey: true,
+                                isAutoIncrement: true,
+                                isUnique: false,
+                            },
+                        ],
+                    });
+                }
+                return Promise.resolve(undefined);
+            }),
+        };
+        migrator.schemaIntrospector = introspector;
+        await migrator.autoSync({ logging: true });
+        const querier = (await pool.getQuerier());
+        expect(querier.run).toHaveBeenCalledWith(expect.stringContaining('ALTER TABLE "SyncUser" ADD COLUMN "name" VARCHAR(255)'));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrator.test.js","sourceRoot":"","sources":["../../src/migrate/migrator.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { beforeEach, describe, expect, it, jest } from 'bun:test';\nimport { Entity, Field, Id } from '../entity/index.js';\nimport type { QuerierPool, SqlQuerier, TableSchema } from '../type/index.js';\nimport { Migrator } from './migrator.js';\n\n@Entity()\nclass SyncUser {\n  @Id() id?: number;\n  @Field() name?: string;\n}\n\n@Entity()\nclass SyncProfile {\n  @Id() id?: number;\n  @Field() bio?: string;\n  @Field({ reference: () => SyncUser }) userId?: number;\n}\n\ndescribe('Migrator autoSync Integration', () => {\n  let migrator: Migrator;\n  let pool: QuerierPool;\n\n  beforeEach(() => {\n    // Mock pool and querier for testing\n    const querier = {\n      run: jest.fn<any>().mockResolvedValue({}),\n      all: jest.fn<any>().mockResolvedValue([]),\n      beginTransaction: jest.fn<any>().mockResolvedValue(undefined),\n      commitTransaction: jest.fn<any>().mockResolvedValue(undefined),\n      rollbackTransaction: jest.fn<any>().mockResolvedValue(undefined),\n      release: jest.fn<any>().mockResolvedValue(undefined),\n      dialect: {\n        escapeIdChar: '\"',\n        placeholder: jest.fn<any>().mockReturnValue('?'),\n      },\n    };\n    pool = {\n      getQuerier: jest.fn<any>().mockResolvedValue(querier),\n      dialect: 'postgres',\n    } as unknown as QuerierPool;\n\n    migrator = new Migrator(pool, {\n      entities: [SyncUser, SyncProfile],\n    });\n  });\n\n  it('should generate create statements for new tables', async () => {\n    // Mock introspector to return nothing\n    const introspector = {\n      getTableSchema: jest.fn<any>().mockResolvedValue(undefined),\n      getTableNames: jest.fn<any>().mockResolvedValue([]),\n      tableExists: jest.fn<any>().mockResolvedValue(false),\n    };\n    migrator.schemaIntrospector = introspector as any;\n\n    await migrator.autoSync({ logging: true });\n\n    const querier = (await pool.getQuerier()) as SqlQuerier;\n    expect(querier.run).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE \"SyncUser\"'));\n    expect(querier.run).toHaveBeenCalledWith(expect.stringContaining('CREATE TABLE \"SyncProfile\"'));\n  });\n\n  it('should generate alter statements for missing columns', async () => {\n    // Mock introspector to return existing table with one column missing\n    const introspector = {\n      getTableSchema: jest.fn<any>().mockImplementation((name: any) => {\n        if (name === 'SyncUser') {\n          return Promise.resolve({\n            name: 'SyncUser',\n            columns: [\n              {\n                name: 'id',\n                type: 'INTEGER',\n                nullable: false,\n                isPrimaryKey: true,\n                isAutoIncrement: true,\n                isUnique: false,\n              },\n            ],\n          } as TableSchema);\n        }\n        return Promise.resolve(undefined);\n      }),\n    };\n    migrator.schemaIntrospector = introspector as any;\n\n    await migrator.autoSync({ logging: true });\n\n    const querier = (await pool.getQuerier()) as SqlQuerier;\n    expect(querier.run).toHaveBeenCalledWith(\n      expect.stringContaining('ALTER TABLE \"SyncUser\" ADD COLUMN \"name\" VARCHAR(255)'),\n    );\n  });\n});\n"]}

package/dist/migrate/schemaGenerator.d.ts

@@ -0,0 +1,78 @@
+import { AbstractDialect } from '../dialect/index.js';
+import type { ColumnSchema, ColumnType, EntityMeta, FieldOptions, IndexSchema, NamingStrategy, SchemaDiff, SchemaGenerator, TableSchema, Type } from '../type/index.js';
+/**
+ * Abstract base class for SQL schema generation
+ */
+export declare abstract class AbstractSchemaGenerator extends AbstractDialect implements SchemaGenerator {
+    protected readonly escapeIdChar: '`' | '"';
+    /**
+     * Primary key type for auto-increment integer IDs
+     */
+    protected abstract readonly serialPrimaryKeyType: string;
+    constructor(namingStrategy?: NamingStrategy, escapeIdChar?: '`' | '"');
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     */
+    protected escapeId(identifier: string): string;
+    generateCreateTable<E>(entity: Type<E>, options?: {
+        ifNotExists?: boolean;
+    }): string;
+    generateDropTable<E>(entity: Type<E>): string;
+    generateAlterTable(diff: SchemaDiff): string[];
+    generateAlterTableDown(diff: SchemaDiff): string[];
+    generateCreateIndex(tableName: string, index: IndexSchema): string;
+    generateDropIndex(tableName: string, indexName: string): string;
+    /**
+     * Generate column definitions from entity metadata
+     */
+    generateColumnDefinitions<E>(meta: EntityMeta<E>): string[];
+    /**
+     * Generate a single column definition
+     */
+    generateColumnDefinition<E>(fieldKey: string, field: FieldOptions, meta: EntityMeta<E>): string;
+    /**
+     * Generate column definition from a ColumnSchema object
+     */
+    generateColumnDefinitionFromSchema(column: ColumnSchema): string;
+    /**
+     * Generate table constraints (indexes, foreign keys, etc.)
+     */
+    generateTableConstraints<E>(meta: EntityMeta<E>): string[];
+    getSqlType(field: FieldOptions, fieldType?: unknown): string;
+    /**
+     * Map uql column type to database-specific SQL type
+     */
+    abstract mapColumnType(columnType: ColumnType, field: FieldOptions): string;
+    /**
+     * Get the boolean type for this database
+     */
+    abstract getBooleanType(): string;
+    /**
+     * Generate ALTER COLUMN statements (database-specific)
+     */
+    abstract generateAlterColumnStatements(tableName: string, column: ColumnSchema, newDefinition: string): string[];
+    /**
+     * Get table options (e.g., ENGINE for MySQL)
+     */
+    getTableOptions<E>(meta: EntityMeta<E>): string;
+    /**
+     * Generate column comment clause (if supported)
+     */
+    abstract generateColumnComment(tableName: string, columnName: string, comment: string): string;
+    /**
+     * Format a default value for SQL
+     */
+    formatDefaultValue(value: unknown): string;
+    /**
+     * Compare two schemas and return the differences
+     */
+    diffSchema<E>(entity: Type<E>, currentSchema: TableSchema | undefined): SchemaDiff | undefined;
+    /**
+     * Convert field options to ColumnSchema
+     */
+    protected fieldToColumnSchema<E>(fieldKey: string, field: FieldOptions, meta: EntityMeta<E>): ColumnSchema;
+    /**
+     * Check if two columns differ enough to require alteration
+     */
+    protected columnsNeedAlteration(current: ColumnSchema, desired: ColumnSchema): boolean;
+}

package/dist/migrate/schemaGenerator.js

@@ -0,0 +1,363 @@
+import { AbstractDialect } from '../dialect/index.js';
+import { getMeta } from '../entity/index.js';
+import { escapeSqlId, getKeys } from '../util/index.js';
+/**
+ * Abstract base class for SQL schema generation
+ */
+export class AbstractSchemaGenerator extends AbstractDialect {
+    escapeIdChar;
+    constructor(namingStrategy, escapeIdChar = '`') {
+        super(namingStrategy);
+        this.escapeIdChar = escapeIdChar;
+    }
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     */
+    escapeId(identifier) {
+        return escapeSqlId(identifier, this.escapeIdChar);
+    }
+    generateCreateTable(entity, options = {}) {
+        const meta = getMeta(entity);
+        const tableName = this.resolveTableName(entity, meta);
+        const columns = this.generateColumnDefinitions(meta);
+        const constraints = this.generateTableConstraints(meta);
+        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
+        let sql = `CREATE TABLE ${ifNotExists}${this.escapeId(tableName)} (\n`;
+        sql += columns.map((col) => `  ${col}`).join(',\n');
+        if (constraints.length > 0) {
+            sql += ',\n';
+            sql += constraints.map((c) => `  ${c}`).join(',\n');
+        }
+        sql += '\n)';
+        sql += this.getTableOptions(meta);
+        sql += ';';
+        return sql;
+    }
+    generateDropTable(entity) {
+        const meta = getMeta(entity);
+        const tableName = this.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);
+        // Rollback additions by dropping columns
+        if (diff.columnsToAdd?.length) {
+            for (const column of diff.columnsToAdd) {
+                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
+            }
+        }
+        return statements;
+    }
+    generateCreateIndex(tableName, index) {
+        const unique = index.unique ? 'UNIQUE ' : '';
+        const columns = index.columns.map((c) => this.escapeId(c)).join(', ');
+        return `CREATE ${unique}INDEX ${this.escapeId(index.name)} ON ${this.escapeId(tableName)} (${columns});`;
+    }
+    generateDropIndex(tableName, indexName) {
+        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
+    }
+    /**
+     * Generate column definitions from entity metadata
+     */
+    generateColumnDefinitions(meta) {
+        const columns = [];
+        const fieldKeys = getKeys(meta.fields);
+        for (const key of fieldKeys) {
+            const field = meta.fields[key];
+            if (field?.virtual)
+                continue; // Skip virtual fields
+            const colDef = this.generateColumnDefinition(key, field, meta);
+            columns.push(colDef);
+        }
+        return columns;
+    }
+    /**
+     * Generate a single column definition
+     */
+    generateColumnDefinition(fieldKey, field, meta) {
+        const columnName = this.escapeId(this.resolveColumnName(fieldKey, field));
+        const isId = field.isId === true;
+        const isPrimaryKey = isId && meta.id === fieldKey;
+        // Determine SQL type
+        let sqlType;
+        if (isPrimaryKey && field.autoIncrement !== false && !field.onInsert) {
+            // Auto-increment primary key
+            sqlType = this.serialPrimaryKeyType;
+        }
+        else {
+            sqlType = this.getSqlType(field, field.type);
+        }
+        let definition = `${columnName} ${sqlType}`;
+        // PRIMARY KEY constraint (for non-serial types)
+        if (isPrimaryKey && !sqlType.includes('PRIMARY KEY')) {
+            definition += ' PRIMARY KEY';
+        }
+        // NULL/NOT NULL
+        if (!isPrimaryKey) {
+            const nullable = field.nullable ?? true;
+            if (!nullable) {
+                definition += ' NOT NULL';
+            }
+        }
+        // UNIQUE constraint
+        if (field.unique && !isPrimaryKey) {
+            definition += ' UNIQUE';
+        }
+        // DEFAULT value
+        if (field.defaultValue !== undefined) {
+            definition += ` DEFAULT ${this.formatDefaultValue(field.defaultValue)}`;
+        }
+        // COMMENT (if supported)
+        if (field.comment) {
+            definition += this.generateColumnComment(this.resolveTableName(meta.entity, meta), this.resolveColumnName(fieldKey, field), field.comment);
+        }
+        return definition;
+    }
+    /**
+     * Generate column definition from a ColumnSchema object
+     */
+    generateColumnDefinitionFromSchema(column) {
+        const columnName = this.escapeId(column.name);
+        let type = column.type;
+        if (column.length && !type.includes('(')) {
+            type = `${type}(${column.length})`;
+        }
+        else if (column.precision !== undefined && !type.includes('(')) {
+            if (column.scale !== undefined) {
+                type = `${type}(${column.precision}, ${column.scale})`;
+            }
+            else {
+                type = `${type}(${column.precision})`;
+            }
+        }
+        let definition = `${columnName} ${type}`;
+        if (column.isPrimaryKey) {
+            definition += ' PRIMARY KEY';
+        }
+        if (!column.nullable && !column.isPrimaryKey) {
+            definition += ' NOT NULL';
+        }
+        if (column.isUnique && !column.isPrimaryKey) {
+            definition += ' UNIQUE';
+        }
+        if (column.defaultValue !== undefined) {
+            definition += ` DEFAULT ${this.formatDefaultValue(column.defaultValue)}`;
+        }
+        return definition;
+    }
+    /**
+     * Generate table constraints (indexes, foreign keys, etc.)
+     */
+    generateTableConstraints(meta) {
+        const constraints = [];
+        const fieldKeys = getKeys(meta.fields);
+        const tableName = this.resolveTableName(meta.entity, meta);
+        // Generate indexes from field options
+        for (const key of fieldKeys) {
+            const field = meta.fields[key];
+            if (field?.index) {
+                const columnName = this.resolveColumnName(key, field);
+                const indexName = typeof field.index === 'string' ? field.index : `idx_${tableName}_${columnName}`;
+                constraints.push(`INDEX ${this.escapeId(indexName)} (${this.escapeId(columnName)})`);
+            }
+        }
+        // Generate foreign key constraints from references
+        for (const key of fieldKeys) {
+            const field = meta.fields[key];
+            if (field?.reference) {
+                const refEntity = field.reference();
+                const refMeta = getMeta(refEntity);
+                const refIdField = refMeta.fields[refMeta.id];
+                const columnName = this.resolveColumnName(key, field);
+                const refTableName = this.resolveTableName(refEntity, refMeta);
+                const refColumnName = this.resolveColumnName(refMeta.id, refIdField);
+                const fkName = `fk_${tableName}_${columnName}`;
+                constraints.push(`CONSTRAINT ${this.escapeId(fkName)} FOREIGN KEY (${this.escapeId(columnName)}) ` +
+                    `REFERENCES ${this.escapeId(refTableName)} (${this.escapeId(refColumnName)})`);
+            }
+        }
+        return constraints;
+    }
+    getSqlType(field, fieldType) {
+        // Use explicit column type if specified
+        if (field.columnType) {
+            return this.mapColumnType(field.columnType, field);
+        }
+        // Handle special types
+        if (field.type === 'json' || field.type === 'jsonb') {
+            return this.mapColumnType(field.type, field);
+        }
+        if (field.type === 'vector') {
+            return this.mapColumnType('vector', field);
+        }
+        // Infer from TypeScript type
+        const type = fieldType ?? field.type;
+        if (type === Number || type === 'number') {
+            return field.precision ? this.mapColumnType('decimal', field) : 'BIGINT';
+        }
+        if (type === String || type === 'string') {
+            const length = field.length ?? 255;
+            return `VARCHAR(${length})`;
+        }
+        if (type === Boolean || type === 'boolean') {
+            return this.getBooleanType();
+        }
+        if (type === Date || type === 'date') {
+            return 'TIMESTAMP';
+        }
+        if (type === BigInt || type === 'bigint') {
+            return 'BIGINT';
+        }
+        // Default to VARCHAR
+        return `VARCHAR(${field.length ?? 255})`;
+    }
+    /**
+     * Get table options (e.g., ENGINE for MySQL)
+     */
+    getTableOptions(meta) {
+        return '';
+    }
+    /**
+     * Format a default value for SQL
+     */
+    formatDefaultValue(value) {
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            return `'${value.replace(/'/g, "''")}'`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'TRUE' : 'FALSE';
+        }
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        return String(value);
+    }
+    /**
+     * Compare two schemas and return the differences
+     */
+    diffSchema(entity, currentSchema) {
+        const meta = getMeta(entity);
+        if (!currentSchema) {
+            // Table doesn't exist, need to create
+            return {
+                tableName: this.resolveTableName(entity, meta),
+                type: 'create',
+            };
+        }
+        const columnsToAdd = [];
+        const columnsToAlter = [];
+        const columnsToDrop = [];
+        const currentColumns = new Map(currentSchema.columns.map((c) => [c.name, c]));
+        const fieldKeys = getKeys(meta.fields);
+        // Check for new or altered columns
+        for (const key of fieldKeys) {
+            const field = meta.fields[key];
+            if (field?.virtual)
+                continue;
+            const columnName = this.resolveColumnName(key, field);
+            const currentColumn = currentColumns.get(columnName);
+            if (!currentColumn) {
+                // Column needs to be added
+                columnsToAdd.push(this.fieldToColumnSchema(key, field, meta));
+            }
+            else {
+                // Check if column needs alteration
+                const desiredColumn = this.fieldToColumnSchema(key, field, meta);
+                if (this.columnsNeedAlteration(currentColumn, desiredColumn)) {
+                    columnsToAlter.push({ from: currentColumn, to: desiredColumn });
+                }
+            }
+            currentColumns.delete(columnName);
+        }
+        // Remaining columns in currentColumns should be dropped
+        for (const [name] of currentColumns) {
+            columnsToDrop.push(name);
+        }
+        if (columnsToAdd.length === 0 && columnsToAlter.length === 0 && columnsToDrop.length === 0) {
+            return undefined; // No changes needed
+        }
+        return {
+            tableName: this.resolveTableName(entity, meta),
+            type: 'alter',
+            columnsToAdd: columnsToAdd.length > 0 ? columnsToAdd : undefined,
+            columnsToAlter: columnsToAlter.length > 0 ? columnsToAlter : undefined,
+            columnsToDrop: columnsToDrop.length > 0 ? columnsToDrop : undefined,
+        };
+    }
+    /**
+     * Convert field options to ColumnSchema
+     */
+    fieldToColumnSchema(fieldKey, field, meta) {
+        const isId = field.isId === true;
+        const isPrimaryKey = isId && meta.id === fieldKey;
+        return {
+            name: this.resolveColumnName(fieldKey, field),
+            type: this.getSqlType(field, field.type),
+            nullable: field.nullable ?? !isPrimaryKey,
+            defaultValue: field.defaultValue,
+            isPrimaryKey,
+            isAutoIncrement: isPrimaryKey && field.autoIncrement !== false && !field.onInsert,
+            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) {
+        // Compare relevant properties
+        return (current.type.toLowerCase() !== desired.type.toLowerCase() ||
+            current.nullable !== desired.nullable ||
+            current.isUnique !== desired.isUnique ||
+            JSON.stringify(current.defaultValue) !== JSON.stringify(desired.defaultValue));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schemaGenerator.js","sourceRoot":"","sources":["../../src/migrate/schemaGenerator.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractDialect } from '../dialect/index.js';\nimport { getMeta } from '../entity/index.js';\nimport type {\n  ColumnSchema,\n  ColumnType,\n  EntityMeta,\n  FieldKey,\n  FieldOptions,\n  IndexSchema,\n  NamingStrategy,\n  SchemaDiff,\n  SchemaGenerator,\n  TableSchema,\n  Type,\n} from '../type/index.js';\nimport { escapeSqlId, getKeys } from '../util/index.js';\n\n/**\n * Abstract base class for SQL schema generation\n */\nexport abstract class AbstractSchemaGenerator extends AbstractDialect implements SchemaGenerator {\n  /**\n   * Primary key type for auto-increment integer IDs\n   */\n  protected abstract readonly serialPrimaryKeyType: string;\n\n  constructor(\n    namingStrategy?: NamingStrategy,\n    protected readonly escapeIdChar: '`' | '\"' = '`',\n  ) {\n    super(namingStrategy);\n  }\n\n  /**\n   * Escape an identifier (table name, column name, etc.)\n   */\n  protected escapeId(identifier: string): string {\n    return escapeSqlId(identifier, this.escapeIdChar);\n  }\n\n  generateCreateTable<E>(entity: Type<E>, options: { ifNotExists?: boolean } = {}): string {\n    const meta = getMeta(entity);\n    const tableName = this.resolveTableName(entity, meta);\n    const columns = this.generateColumnDefinitions(meta);\n    const constraints = this.generateTableConstraints(meta);\n\n    const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';\n    let sql = `CREATE TABLE ${ifNotExists}${this.escapeId(tableName)} (\\n`;\n    sql += columns.map((col) => `  ${col}`).join(',\\n');\n\n    if (constraints.length > 0) {\n      sql += ',\\n';\n      sql += constraints.map((c: any) => `  ${c}`).join(',\\n');\n    }\n\n    sql += '\\n)';\n    sql += this.getTableOptions(meta);\n    sql += ';';\n\n    return sql;\n  }\n\n  generateDropTable<E>(entity: Type<E>): string {\n    const meta = getMeta(entity);\n    const tableName = this.resolveTableName(entity, meta);\n    return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;\n  }\n\n  generateAlterTable(diff: SchemaDiff): string[] {\n    const statements: string[] = [];\n    const tableName = this.escapeId(diff.tableName);\n\n    // Add new columns\n    if (diff.columnsToAdd?.length) {\n      for (const column of diff.columnsToAdd) {\n        const colDef = this.generateColumnDefinitionFromSchema(column);\n        statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${colDef};`);\n      }\n    }\n\n    // Alter existing columns\n    if (diff.columnsToAlter?.length) {\n      for (const { to } of diff.columnsToAlter) {\n        const colDef = this.generateColumnDefinitionFromSchema(to);\n        const colStatements = this.generateAlterColumnStatements(diff.tableName, to, colDef);\n        statements.push(...colStatements);\n      }\n    }\n\n    // Drop columns\n    if (diff.columnsToDrop?.length) {\n      for (const columnName of diff.columnsToDrop) {\n        statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);\n      }\n    }\n\n    // Add indexes\n    if (diff.indexesToAdd?.length) {\n      for (const index of diff.indexesToAdd) {\n        statements.push(this.generateCreateIndex(diff.tableName, index));\n      }\n    }\n\n    // Drop indexes\n    if (diff.indexesToDrop?.length) {\n      for (const indexName of diff.indexesToDrop) {\n        statements.push(this.generateDropIndex(diff.tableName, indexName));\n      }\n    }\n\n    return statements;\n  }\n\n  generateAlterTableDown(diff: SchemaDiff): string[] {\n    const statements: string[] = [];\n    const tableName = this.escapeId(diff.tableName);\n\n    // Rollback additions by dropping columns\n    if (diff.columnsToAdd?.length) {\n      for (const column of diff.columnsToAdd) {\n        statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);\n      }\n    }\n\n    return statements;\n  }\n\n  generateCreateIndex(tableName: string, index: IndexSchema): string {\n    const unique = index.unique ? 'UNIQUE ' : '';\n    const columns = index.columns.map((c: any) => this.escapeId(c)).join(', ');\n    return `CREATE ${unique}INDEX ${this.escapeId(index.name)} ON ${this.escapeId(tableName)} (${columns});`;\n  }\n\n  generateDropIndex(tableName: string, indexName: string): string {\n    return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;\n  }\n\n  /**\n   * Generate column definitions from entity metadata\n   */\n  public generateColumnDefinitions<E>(meta: EntityMeta<E>): string[] {\n    const columns: string[] = [];\n    const fieldKeys = getKeys(meta.fields) as FieldKey<E>[];\n\n    for (const key of fieldKeys) {\n      const field = meta.fields[key];\n      if (field?.virtual) continue; // Skip virtual fields\n\n      const colDef = this.generateColumnDefinition(key as string, field, meta);\n      columns.push(colDef);\n    }\n\n    return columns;\n  }\n\n  /**\n   * Generate a single column definition\n   */\n  public generateColumnDefinition<E>(fieldKey: string, field: FieldOptions, meta: EntityMeta<E>): string {\n    const columnName = this.escapeId(this.resolveColumnName(fieldKey, field));\n    const isId = field.isId === true;\n    const isPrimaryKey = isId && meta.id === fieldKey;\n\n    // Determine SQL type\n    let sqlType: string;\n    if (isPrimaryKey && field.autoIncrement !== false && !field.onInsert) {\n      // Auto-increment primary key\n      sqlType = this.serialPrimaryKeyType;\n    } else {\n      sqlType = this.getSqlType(field, field.type);\n    }\n\n    let definition = `${columnName} ${sqlType}`;\n\n    // PRIMARY KEY constraint (for non-serial types)\n    if (isPrimaryKey && !sqlType.includes('PRIMARY KEY')) {\n      definition += ' PRIMARY KEY';\n    }\n\n    // NULL/NOT NULL\n    if (!isPrimaryKey) {\n      const nullable = field.nullable ?? true;\n      if (!nullable) {\n        definition += ' NOT NULL';\n      }\n    }\n\n    // UNIQUE constraint\n    if (field.unique && !isPrimaryKey) {\n      definition += ' UNIQUE';\n    }\n\n    // DEFAULT value\n    if (field.defaultValue !== undefined) {\n      definition += ` DEFAULT ${this.formatDefaultValue(field.defaultValue)}`;\n    }\n\n    // COMMENT (if supported)\n    if (field.comment) {\n      definition += this.generateColumnComment(\n        this.resolveTableName(meta.entity, meta),\n        this.resolveColumnName(fieldKey, field),\n        field.comment,\n      );\n    }\n\n    return definition;\n  }\n\n  /**\n   * Generate column definition from a ColumnSchema object\n   */\n  public generateColumnDefinitionFromSchema(column: ColumnSchema): string {\n    const columnName = this.escapeId(column.name);\n    let type = column.type;\n\n    if (column.length && !type.includes('(')) {\n      type = `${type}(${column.length})`;\n    } else if (column.precision !== undefined && !type.includes('(')) {\n      if (column.scale !== undefined) {\n        type = `${type}(${column.precision}, ${column.scale})`;\n      } else {\n        type = `${type}(${column.precision})`;\n      }\n    }\n\n    let definition = `${columnName} ${type}`;\n\n    if (column.isPrimaryKey) {\n      definition += ' PRIMARY KEY';\n    }\n\n    if (!column.nullable && !column.isPrimaryKey) {\n      definition += ' NOT NULL';\n    }\n\n    if (column.isUnique && !column.isPrimaryKey) {\n      definition += ' UNIQUE';\n    }\n\n    if (column.defaultValue !== undefined) {\n      definition += ` DEFAULT ${this.formatDefaultValue(column.defaultValue)}`;\n    }\n\n    return definition;\n  }\n\n  /**\n   * Generate table constraints (indexes, foreign keys, etc.)\n   */\n  public generateTableConstraints<E>(meta: EntityMeta<E>): string[] {\n    const constraints: string[] = [];\n    const fieldKeys = getKeys(meta.fields) as FieldKey<E>[];\n    const tableName = this.resolveTableName(meta.entity, meta);\n\n    // Generate indexes from field options\n    for (const key of fieldKeys) {\n      const field = meta.fields[key];\n      if (field?.index) {\n        const columnName = this.resolveColumnName(key as string, field);\n        const indexName = typeof field.index === 'string' ? field.index : `idx_${tableName}_${columnName}`;\n        constraints.push(`INDEX ${this.escapeId(indexName)} (${this.escapeId(columnName)})`);\n      }\n    }\n\n    // Generate foreign key constraints from references\n    for (const key of fieldKeys) {\n      const field = meta.fields[key];\n      if (field?.reference) {\n        const refEntity = field.reference();\n        const refMeta = getMeta(refEntity);\n        const refIdField = refMeta.fields[refMeta.id];\n        const columnName = this.resolveColumnName(key as string, field);\n        const refTableName = this.resolveTableName(refEntity, refMeta);\n        const refColumnName = this.resolveColumnName(refMeta.id, refIdField);\n        const fkName = `fk_${tableName}_${columnName}`;\n\n        constraints.push(\n          `CONSTRAINT ${this.escapeId(fkName)} FOREIGN KEY (${this.escapeId(columnName)}) ` +\n            `REFERENCES ${this.escapeId(refTableName)} (${this.escapeId(refColumnName)})`,\n        );\n      }\n    }\n\n    return constraints;\n  }\n\n  getSqlType(field: FieldOptions, fieldType?: unknown): string {\n    // Use explicit column type if specified\n    if (field.columnType) {\n      return this.mapColumnType(field.columnType, field);\n    }\n\n    // Handle special types\n    if (field.type === 'json' || field.type === 'jsonb') {\n      return this.mapColumnType(field.type as ColumnType, field);\n    }\n\n    if (field.type === 'vector') {\n      return this.mapColumnType('vector', field);\n    }\n\n    // Infer from TypeScript type\n    const type = fieldType ?? field.type;\n\n    if (type === Number || type === 'number') {\n      return field.precision ? this.mapColumnType('decimal', field) : 'BIGINT';\n    }\n\n    if (type === String || type === 'string') {\n      const length = field.length ?? 255;\n      return `VARCHAR(${length})`;\n    }\n\n    if (type === Boolean || type === 'boolean') {\n      return this.getBooleanType();\n    }\n\n    if (type === Date || type === 'date') {\n      return 'TIMESTAMP';\n    }\n\n    if (type === BigInt || type === 'bigint') {\n      return 'BIGINT';\n    }\n\n    // Default to VARCHAR\n    return `VARCHAR(${field.length ?? 255})`;\n  }\n\n  /**\n   * Map uql column type to database-specific SQL type\n   */\n  public abstract mapColumnType(columnType: ColumnType, field: FieldOptions): string;\n\n  /**\n   * Get the boolean type for this database\n   */\n  public abstract getBooleanType(): string;\n\n  /**\n   * Generate ALTER COLUMN statements (database-specific)\n   */\n  public abstract generateAlterColumnStatements(\n    tableName: string,\n    column: ColumnSchema,\n    newDefinition: string,\n  ): string[];\n\n  /**\n   * Get table options (e.g., ENGINE for MySQL)\n   */\n  getTableOptions<E>(meta: EntityMeta<E>): string {\n    return '';\n  }\n\n  /**\n   * Generate column comment clause (if supported)\n   */\n  public abstract generateColumnComment(tableName: string, columnName: string, comment: string): string;\n\n  /**\n   * Format a default value for SQL\n   */\n  public formatDefaultValue(value: unknown): string {\n    if (value === null) {\n      return 'NULL';\n    }\n    if (typeof value === 'string') {\n      return `'${value.replace(/'/g, \"''\")}'`;\n    }\n    if (typeof value === 'boolean') {\n      return value ? 'TRUE' : 'FALSE';\n    }\n    if (typeof value === 'number' || typeof value === 'bigint') {\n      return String(value);\n    }\n    if (value instanceof Date) {\n      return `'${value.toISOString()}'`;\n    }\n    return String(value);\n  }\n\n  /**\n   * Compare two schemas and return the differences\n   */\n  diffSchema<E>(entity: Type<E>, currentSchema: TableSchema | undefined): SchemaDiff | undefined {\n    const meta = getMeta(entity);\n\n    if (!currentSchema) {\n      // Table doesn't exist, need to create\n      return {\n        tableName: this.resolveTableName(entity, meta),\n        type: 'create',\n      };\n    }\n\n    const columnsToAdd: ColumnSchema[] = [];\n    const columnsToAlter: { from: ColumnSchema; to: ColumnSchema }[] = [];\n    const columnsToDrop: string[] = [];\n\n    const currentColumns = new Map(currentSchema.columns.map((c: any) => [c.name, c]));\n    const fieldKeys = getKeys(meta.fields) as FieldKey<E>[];\n\n    // Check for new or altered columns\n    for (const key of fieldKeys) {\n      const field = meta.fields[key];\n      if (field?.virtual) continue;\n\n      const columnName = this.resolveColumnName(key as string, field);\n      const currentColumn = currentColumns.get(columnName);\n\n      if (!currentColumn) {\n        // Column needs to be added\n        columnsToAdd.push(this.fieldToColumnSchema(key as string, field, meta));\n      } else {\n        // Check if column needs alteration\n        const desiredColumn = this.fieldToColumnSchema(key as string, field, meta);\n        if (this.columnsNeedAlteration(currentColumn, desiredColumn)) {\n          columnsToAlter.push({ from: currentColumn, to: desiredColumn });\n        }\n      }\n      currentColumns.delete(columnName);\n    }\n\n    // Remaining columns in currentColumns should be dropped\n    for (const [name] of currentColumns) {\n      columnsToDrop.push(name);\n    }\n\n    if (columnsToAdd.length === 0 && columnsToAlter.length === 0 && columnsToDrop.length === 0) {\n      return undefined; // No changes needed\n    }\n\n    return {\n      tableName: this.resolveTableName(entity, meta),\n      type: 'alter',\n      columnsToAdd: columnsToAdd.length > 0 ? columnsToAdd : undefined,\n      columnsToAlter: columnsToAlter.length > 0 ? columnsToAlter : undefined,\n      columnsToDrop: columnsToDrop.length > 0 ? columnsToDrop : undefined,\n    };\n  }\n\n  /**\n   * Convert field options to ColumnSchema\n   */\n  protected fieldToColumnSchema<E>(fieldKey: string, field: FieldOptions, meta: EntityMeta<E>): ColumnSchema {\n    const isId = field.isId === true;\n    const isPrimaryKey = isId && meta.id === fieldKey;\n\n    return {\n      name: this.resolveColumnName(fieldKey, field),\n      type: this.getSqlType(field, field.type),\n      nullable: field.nullable ?? !isPrimaryKey,\n      defaultValue: field.defaultValue,\n      isPrimaryKey,\n      isAutoIncrement: isPrimaryKey && field.autoIncrement !== false && !field.onInsert,\n      isUnique: field.unique ?? false,\n      length: field.length,\n      precision: field.precision,\n      scale: field.scale,\n      comment: field.comment,\n    };\n  }\n\n  /**\n   * Check if two columns differ enough to require alteration\n   */\n  protected columnsNeedAlteration(current: ColumnSchema, desired: ColumnSchema): boolean {\n    // Compare relevant properties\n    return (\n      current.type.toLowerCase() !== desired.type.toLowerCase() ||\n      current.nullable !== desired.nullable ||\n      current.isUnique !== desired.isUnique ||\n      JSON.stringify(current.defaultValue) !== JSON.stringify(desired.defaultValue)\n    );\n  }\n}\n"]}