ts-prorm-orm 1.1.0

package/dist/schema/migration-generator.js

@@ -0,0 +1,374 @@
+"use strict";
+/**
+ * Migration Generator
+ * Generates migration scripts from schema diffs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationGenerator = void 0;
+exports.createMigrationGenerator = createMigrationGenerator;
+/**
+ * MigrationGenerator generates SQL migration scripts from schema diffs
+ */
+class MigrationGenerator {
+    constructor(dialect, options = {}) {
+        this.dialect = dialect;
+        this.options = {
+            generateDown: true,
+            includeComments: true,
+            namePrefix: 'migration',
+            ...options,
+        };
+    }
+    /**
+     * Generate a migration script from a schema diff
+     */
+    generateMigration(diff, options) {
+        const opts = { ...this.options, ...options };
+        const up = [];
+        const down = [];
+        if (opts.includeComments) {
+            up.push(`-- Migration: ${diff.tableName}`);
+            up.push(`-- Generated at: ${new Date().toISOString()}`);
+            up.push('');
+        }
+        const { columns, indexes, constraints, foreignKeys } = diff.changes;
+        // Process column changes
+        for (const change of columns) {
+            const columnMigration = this.generateColumnMigration(change, diff.tableName);
+            up.push(...columnMigration.up);
+            if (opts.generateDown) {
+                down.push(...columnMigration.down);
+            }
+        }
+        // Process index changes
+        for (const change of indexes) {
+            const indexMigration = this.generateIndexMigration(change, diff.tableName);
+            up.push(...indexMigration.up);
+            if (opts.generateDown) {
+                down.push(...indexMigration.down);
+            }
+        }
+        // Process constraint changes
+        for (const change of constraints) {
+            const constraintMigration = this.generateConstraintMigration(change, diff.tableName);
+            up.push(...constraintMigration.up);
+            if (opts.generateDown) {
+                down.push(...constraintMigration.down);
+            }
+        }
+        // Process foreign key changes
+        for (const change of foreignKeys) {
+            const fkMigration = this.generateForeignKeyMigration(change, diff.tableName);
+            up.push(...fkMigration.up);
+            if (opts.generateDown) {
+                down.push(...fkMigration.down);
+            }
+        }
+        // Generate migration name
+        const timestamp = Date.now();
+        const migrationName = `${opts.namePrefix}_${timestamp}_${diff.tableName}`;
+        return {
+            name: migrationName,
+            up,
+            down: opts.generateDown ? down.reverse() : [],
+            modelName: diff.modelName,
+            tableName: diff.tableName,
+            generatedAt: new Date(),
+        };
+    }
+    /**
+     * Generate migration scripts for all schema diffs
+     */
+    generateAllMigrations(diffs, options) {
+        return diffs.map((diff) => this.generateMigration(diff, options));
+    }
+    // ==================== Private Helper Methods ====================
+    /**
+     * Generate column migration statements
+     */
+    generateColumnMigration(change, tableName) {
+        const up = [];
+        const down = [];
+        switch (change.changeType) {
+            case 'create':
+                if (change.modelDefinition) {
+                    const addColumnSql = this.generateAddColumnSql(tableName, change.modelDefinition);
+                    up.push(addColumnSql);
+                    down.push(`ALTER TABLE ${this.quoteTableName(tableName)} DROP COLUMN ${this.quoteIdentifier(change.columnName)};`);
+                }
+                break;
+            case 'modify':
+                if (change.modelDefinition && change.changedProperties) {
+                    for (const prop of change.changedProperties) {
+                        const modifySql = this.generateModifyColumnSql(tableName, change.columnName, change.modelDefinition, prop);
+                        if (modifySql) {
+                            up.push(modifySql);
+                        }
+                    }
+                    // For down, we would need the original definition - simplified here
+                    down.push(`-- Reverse modification for ${change.columnName}`);
+                }
+                break;
+            case 'delete':
+                if (change.databaseDefinition) {
+                    up.push(`ALTER TABLE ${this.quoteTableName(tableName)} DROP COLUMN ${this.quoteIdentifier(change.columnName)};`);
+                    const recreateSql = this.generateAddColumnSql(tableName, {
+                        name: change.columnName,
+                        typeString: change.databaseDefinition.type,
+                        allowNull: change.databaseDefinition.allowNull,
+                        defaultValue: change.databaseDefinition.defaultValue,
+                        primaryKey: change.databaseDefinition.primaryKey,
+                        autoIncrement: change.databaseDefinition.autoIncrement,
+                        unique: false,
+                    });
+                    down.push(recreateSql);
+                }
+                break;
+        }
+        return { up, down };
+    }
+    /**
+     * Generate index migration statements
+     */
+    generateIndexMigration(change, tableName) {
+        const up = [];
+        const down = [];
+        switch (change.changeType) {
+            case 'create':
+                if (change.modelDefinition) {
+                    const indexSql = this.generateCreateIndexSql(tableName, change.indexName, change.modelDefinition);
+                    up.push(indexSql);
+                    down.push(`DROP INDEX ${this.quoteIdentifier(change.indexName)};`);
+                }
+                break;
+            case 'modify':
+                // For modify, we drop and recreate
+                if (change.modelDefinition && change.databaseDefinition) {
+                    up.push(`DROP INDEX ${this.quoteIdentifier(change.indexName)};`);
+                    up.push(this.generateCreateIndexSql(tableName, change.indexName, change.modelDefinition));
+                    down.push(`DROP INDEX ${this.quoteIdentifier(change.indexName)};`);
+                    if (change.databaseDefinition) {
+                        down.push(this.generateCreateIndexSql(tableName, change.indexName, change.databaseDefinition));
+                    }
+                }
+                break;
+            case 'delete':
+                if (change.databaseDefinition && !change.databaseDefinition.primary) {
+                    up.push(`DROP INDEX ${this.quoteIdentifier(change.indexName)};`);
+                    const recreateSql = this.generateCreateIndexSql(tableName, change.indexName, {
+                        name: change.indexName,
+                        unique: change.databaseDefinition.unique,
+                        fields: change.databaseDefinition.fields,
+                    });
+                    down.push(recreateSql);
+                }
+                break;
+        }
+        return { up, down };
+    }
+    /**
+     * Generate constraint migration statements
+     */
+    generateConstraintMigration(change, tableName) {
+        const up = [];
+        const down = [];
+        switch (change.changeType) {
+            case 'create':
+                if (change.modelDefinition) {
+                    const constraintSql = this.generateAddConstraintSql(tableName, change.constraintName, change.modelDefinition);
+                    up.push(constraintSql);
+                    down.push(`ALTER TABLE ${this.quoteTableName(tableName)} DROP CONSTRAINT ${this.quoteIdentifier(change.constraintName)};`);
+                }
+                break;
+            case 'delete':
+                if (change.databaseDefinition) {
+                    up.push(`ALTER TABLE ${this.quoteTableName(tableName)} DROP CONSTRAINT ${this.quoteIdentifier(change.constraintName)};`);
+                    const recreateSql = this.generateAddConstraintSql(tableName, change.constraintName, {
+                        name: change.constraintName,
+                        type: change.databaseDefinition.type,
+                        fields: change.databaseDefinition.fields || [],
+                    });
+                    down.push(recreateSql);
+                }
+                break;
+        }
+        return { up, down };
+    }
+    /**
+     * Generate foreign key migration statements
+     */
+    generateForeignKeyMigration(change, tableName) {
+        const up = [];
+        const down = [];
+        switch (change.changeType) {
+            case 'create':
+                if (change.modelDefinition) {
+                    const fkSql = this.generateAddForeignKeySql(tableName, change.constraintName, change.modelDefinition);
+                    up.push(fkSql);
+                    down.push(`ALTER TABLE ${this.quoteTableName(tableName)} DROP FOREIGN KEY ${this.quoteIdentifier(change.constraintName)};`);
+                }
+                break;
+            case 'delete':
+                if (change.databaseDefinition) {
+                    up.push(`ALTER TABLE ${this.quoteTableName(tableName)} DROP FOREIGN KEY ${this.quoteIdentifier(change.constraintName)};`);
+                    const recreateSql = this.generateAddForeignKeySql(tableName, change.constraintName, {
+                        name: change.constraintName,
+                        fields: change.databaseDefinition.fields,
+                        references: change.databaseDefinition.references,
+                    });
+                    down.push(recreateSql);
+                }
+                break;
+        }
+        return { up, down };
+    }
+    /**
+     * Generate ADD COLUMN SQL
+     */
+    generateAddColumnSql(tableName, column) {
+        let sql = `ALTER TABLE ${this.quoteTableName(tableName)} ADD COLUMN ${this.quoteIdentifier(column.name)} ${column.typeString}`;
+        if (!column.allowNull) {
+            sql += ' NOT NULL';
+        }
+        if (column.defaultValue !== undefined && column.defaultValue !== null) {
+            sql += ` DEFAULT ${this.formatDefaultValue(column.defaultValue)}`;
+        }
+        if (column.autoIncrement) {
+            // Auto increment is handled by the dialect
+        }
+        if (column.unique && typeof column.unique === 'string') {
+            sql += ` UNIQUE`;
+        }
+        sql += ';';
+        return sql;
+    }
+    /**
+     * Generate MODIFY COLUMN SQL
+     */
+    generateModifyColumnSql(tableName, columnName, column, property) {
+        const dialectName = this.dialect.name;
+        switch (property) {
+            case 'type':
+                if (dialectName === 'mysql' || dialectName === 'mariadb') {
+                    return `ALTER TABLE ${this.quoteTableName(tableName)} MODIFY COLUMN ${this.quoteIdentifier(columnName)} ${column.typeString};`;
+                }
+                else {
+                    return `ALTER TABLE ${this.quoteTableName(tableName)} ALTER COLUMN ${this.quoteIdentifier(columnName)} TYPE ${column.typeString};`;
+                }
+            case 'allowNull':
+                if (dialectName === 'mysql' || dialectName === 'mariadb') {
+                    return column.allowNull
+                        ? `ALTER TABLE ${this.quoteTableName(tableName)} MODIFY COLUMN ${this.quoteIdentifier(columnName)} ${column.typeString} NULL;`
+                        : `ALTER TABLE ${this.quoteTableName(tableName)} MODIFY COLUMN ${this.quoteIdentifier(columnName)} ${column.typeString} NOT NULL;`;
+                }
+                else {
+                    return column.allowNull
+                        ? `ALTER TABLE ${this.quoteTableName(tableName)} ALTER COLUMN ${this.quoteIdentifier(columnName)} DROP NOT NULL;`
+                        : `ALTER TABLE ${this.quoteTableName(tableName)} ALTER COLUMN ${this.quoteIdentifier(columnName)} SET NOT NULL;`;
+                }
+            case 'defaultValue':
+                if (column.defaultValue === null || column.defaultValue === undefined) {
+                    return `ALTER TABLE ${this.quoteTableName(tableName)} ALTER COLUMN ${this.quoteIdentifier(columnName)} DROP DEFAULT;`;
+                }
+                else {
+                    return `ALTER TABLE ${this.quoteTableName(tableName)} ALTER COLUMN ${this.quoteIdentifier(columnName)} SET DEFAULT ${this.formatDefaultValue(column.defaultValue)};`;
+                }
+            default:
+                return null;
+        }
+    }
+    /**
+     * Generate CREATE INDEX SQL
+     */
+    generateCreateIndexSql(tableName, indexName, index) {
+        const uniqueStr = index.unique ? 'UNIQUE ' : '';
+        const fieldsStr = index.fields.map((f) => this.quoteIdentifier(f)).join(', ');
+        return `CREATE ${uniqueStr}INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteTableName(tableName)} (${fieldsStr});`;
+    }
+    /**
+     * Generate ADD CONSTRAINT SQL
+     */
+    generateAddConstraintSql(tableName, constraintName, constraint) {
+        const fieldsStr = constraint.fields.map((f) => this.quoteIdentifier(f)).join(', ');
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                return `ALTER TABLE ${this.quoteTableName(tableName)} ADD CONSTRAINT ${this.quoteIdentifier(constraintName)} PRIMARY KEY (${fieldsStr});`;
+            case 'UNIQUE':
+                return `ALTER TABLE ${this.quoteTableName(tableName)} ADD CONSTRAINT ${this.quoteIdentifier(constraintName)} UNIQUE (${fieldsStr});`;
+            case 'CHECK':
+                return `ALTER TABLE ${this.quoteTableName(tableName)} ADD CONSTRAINT ${this.quoteIdentifier(constraintName)} CHECK (${constraint.check || '1=1'});`;
+            default:
+                return `-- Unknown constraint type: ${constraint.type}`;
+        }
+    }
+    /**
+     * Generate ADD FOREIGN KEY SQL
+     */
+    generateAddForeignKeySql(tableName, constraintName, fk) {
+        const fieldsStr = fk.fields.map((f) => this.quoteIdentifier(f)).join(', ');
+        const refFieldsStr = fk.references.fields.map((f) => this.quoteIdentifier(f)).join(', ');
+        let sql = `ALTER TABLE ${this.quoteTableName(tableName)} ADD CONSTRAINT ${this.quoteIdentifier(constraintName)} `;
+        sql += `FOREIGN KEY (${fieldsStr}) REFERENCES ${this.quoteTableName(fk.references.table)} (${refFieldsStr})`;
+        if (fk.references.onDelete) {
+            sql += ` ON DELETE ${fk.references.onDelete}`;
+        }
+        if (fk.references.onUpdate) {
+            sql += ` ON UPDATE ${fk.references.onUpdate}`;
+        }
+        sql += ';';
+        return sql;
+    }
+    /**
+     * Quote table name based on dialect
+     */
+    quoteTableName(tableName) {
+        const dialectName = this.dialect.name;
+        if (dialectName === 'mssql') {
+            return `[${tableName}]`;
+        }
+        return `"${tableName}"`;
+    }
+    /**
+     * Quote identifier based on dialect
+     */
+    quoteIdentifier(identifier) {
+        const dialectName = this.dialect.name;
+        if (dialectName === 'mssql') {
+            return `[${identifier}]`;
+        }
+        return `"${identifier}"`;
+    }
+    /**
+     * Format 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') {
+            return String(value);
+        }
+        // Handle special values like CURRENT_TIMESTAMP
+        if (typeof value === 'object' && value !== null) {
+            // Check for prorm special values like Prorm.NOW
+            const valStr = String(value);
+            if (valStr.includes('NOW') || valStr.includes('CURRENT_TIMESTAMP')) {
+                return valStr;
+            }
+        }
+        return String(value);
+    }
+}
+exports.MigrationGenerator = MigrationGenerator;
+/**
+ * Create a MigrationGenerator instance
+ */
+function createMigrationGenerator(dialect, options) {
+    return new MigrationGenerator(dialect, options);
+}