ts-prorm-orm 1.1.0

package/dist/schema/schema-differ.js

@@ -0,0 +1,549 @@
+"use strict";
+/**
+ * Schema Differ
+ * Compares model definitions against database schema to detect changes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaDiffer = void 0;
+exports.createSchemaDiffer = createSchemaDiffer;
+/**
+ * SchemaDiffer compares model definitions against database schema
+ */
+class SchemaDiffer {
+    constructor(dialect, options = {}) {
+        this.dialect = dialect;
+        this.options = {
+            compareIndexes: true,
+            compareConstraints: true,
+            compareForeignKeys: true,
+            serializeColumnType: (type) => this.serializeDataType(type),
+            ...options,
+        };
+    }
+    /**
+     * Compare a model against its database table
+     */
+    async diffModel(model) {
+        const tableName = model.tableName || model.name;
+        const schemaName = model.schema;
+        // Get model definition
+        const modelColumns = this.extractColumnDefinitions(model);
+        const modelIndexes = this.extractIndexDefinitions(model);
+        const modelConstraints = this.extractConstraintDefinitions(model);
+        const modelForeignKeys = this.extractForeignKeyDefinitions(model);
+        // Get database definition
+        const dbColumns = await this.getDatabaseColumns(tableName, schemaName);
+        const dbIndexes = this.options.compareIndexes
+            ? await this.getDatabaseIndexes(tableName, schemaName)
+            : [];
+        const dbConstraints = this.options.compareConstraints
+            ? await this.getDatabaseConstraints(tableName, schemaName)
+            : [];
+        const dbForeignKeys = this.options.compareForeignKeys
+            ? await this.getDatabaseForeignKeys(tableName, schemaName)
+            : [];
+        // Compute changes
+        const columnChanges = this.getColumnChanges(modelColumns, dbColumns);
+        const indexChanges = this.getIndexChanges(modelIndexes, dbIndexes);
+        const constraintChanges = this.getConstraintChanges(modelConstraints, dbConstraints);
+        const foreignKeyChanges = this.getForeignKeyChanges(modelForeignKeys, dbForeignKeys);
+        const hasChanges = columnChanges.length > 0 ||
+            indexChanges.length > 0 ||
+            constraintChanges.length > 0 ||
+            foreignKeyChanges.length > 0;
+        return {
+            modelName: model.name,
+            tableName,
+            schemaName,
+            changes: {
+                columns: columnChanges,
+                indexes: indexChanges,
+                constraints: constraintChanges,
+                foreignKeys: foreignKeyChanges,
+            },
+            hasChanges,
+            generatedAt: new Date(),
+        };
+    }
+    /**
+     * Diff all models registered with Prorm
+     */
+    async diffAll() {
+        const prorm = this.dialect.prorm;
+        if (!prorm) {
+            throw new Error('Dialect is not associated with a Prorm instance');
+        }
+        const models = prorm.models || {};
+        const diffs = [];
+        for (const model of Object.values(models)) {
+            if (model && model.name) {
+                const diff = await this.diffModel(model);
+                if (diff.hasChanges) {
+                    diffs.push(diff);
+                }
+            }
+        }
+        return diffs;
+    }
+    /**
+     * Get column changes between model and database
+     */
+    getColumnChanges(modelColumns, dbColumns) {
+        const changes = [];
+        const dbColumnMap = new Map(dbColumns.map((c) => [c.name, c]));
+        const modelColumnMap = new Map(modelColumns.map((c) => [c.name, c]));
+        // Check for new or modified columns
+        for (const modelCol of modelColumns) {
+            const dbCol = dbColumnMap.get(modelCol.name);
+            if (!dbCol) {
+                // New column
+                changes.push({
+                    type: 'column',
+                    changeType: 'create',
+                    columnName: modelCol.name,
+                    modelDefinition: modelCol,
+                });
+            }
+            else {
+                // Check for modifications
+                const changedProps = this.compareColumnDefinitions(modelCol, dbCol);
+                if (changedProps.length > 0) {
+                    changes.push({
+                        type: 'column',
+                        changeType: 'modify',
+                        columnName: modelCol.name,
+                        modelDefinition: modelCol,
+                        databaseDefinition: dbCol,
+                        changedProperties: changedProps,
+                    });
+                }
+            }
+        }
+        // Check for deleted columns
+        for (const dbCol of dbColumns) {
+            if (!modelColumnMap.has(dbCol.name)) {
+                changes.push({
+                    type: 'column',
+                    changeType: 'delete',
+                    columnName: dbCol.name,
+                    databaseDefinition: dbCol,
+                });
+            }
+        }
+        return changes;
+    }
+    /**
+     * Get index changes between model and database
+     */
+    getIndexChanges(modelIndexes, dbIndexes) {
+        const changes = [];
+        const dbIndexMap = new Map(dbIndexes.map((i) => [i.name, i]));
+        const modelIndexMap = new Map(modelIndexes.map((i) => [i.name, i]));
+        // Check for new or modified indexes
+        for (const modelIdx of modelIndexes) {
+            const dbIdx = dbIndexMap.get(modelIdx.name);
+            if (!dbIdx) {
+                changes.push({
+                    type: 'index',
+                    changeType: 'create',
+                    indexName: modelIdx.name,
+                    modelDefinition: modelIdx,
+                });
+            }
+            else {
+                const changedProps = this.compareIndexDefinitions(modelIdx, dbIdx);
+                if (changedProps.length > 0) {
+                    changes.push({
+                        type: 'index',
+                        changeType: 'modify',
+                        indexName: modelIdx.name,
+                        modelDefinition: modelIdx,
+                        databaseDefinition: dbIdx,
+                        changedProperties: changedProps,
+                    });
+                }
+            }
+        }
+        // Check for deleted indexes
+        for (const dbIdx of dbIndexes) {
+            if (!modelIndexMap.has(dbIdx.name) && !dbIdx.primary) {
+                changes.push({
+                    type: 'index',
+                    changeType: 'delete',
+                    indexName: dbIdx.name,
+                    databaseDefinition: dbIdx,
+                });
+            }
+        }
+        return changes;
+    }
+    /**
+     * Get constraint changes between model and database
+     */
+    getConstraintChanges(modelConstraints, dbConstraints) {
+        const changes = [];
+        const dbConstraintMap = new Map(dbConstraints.map((c) => [c.name, c]));
+        const modelConstraintMap = new Map(modelConstraints.map((c) => [c.name, c]));
+        // Check for new or modified constraints
+        for (const modelCon of modelConstraints) {
+            const dbCon = dbConstraintMap.get(modelCon.name);
+            if (!dbCon) {
+                changes.push({
+                    type: 'constraint',
+                    changeType: 'create',
+                    constraintName: modelCon.name,
+                    constraintType: modelCon.type,
+                    modelDefinition: modelCon,
+                });
+            }
+            else {
+                const changedProps = this.compareConstraintDefinitions(modelCon, dbCon);
+                if (changedProps.length > 0) {
+                    changes.push({
+                        type: 'constraint',
+                        changeType: 'modify',
+                        constraintName: modelCon.name,
+                        constraintType: modelCon.type,
+                        modelDefinition: modelCon,
+                        databaseDefinition: dbCon,
+                        changedProperties: changedProps,
+                    });
+                }
+            }
+        }
+        // Check for deleted constraints
+        for (const dbCon of dbConstraints) {
+            if (!modelConstraintMap.has(dbCon.name)) {
+                changes.push({
+                    type: 'constraint',
+                    changeType: 'delete',
+                    constraintName: dbCon.name,
+                    constraintType: dbCon.type,
+                    databaseDefinition: dbCon,
+                });
+            }
+        }
+        return changes;
+    }
+    /**
+     * Get foreign key changes between model and database
+     */
+    getForeignKeyChanges(modelFKs, dbFKs) {
+        const changes = [];
+        const dbFKMap = new Map(dbFKs.map((f) => [f.name, f]));
+        const modelFKMap = new Map(modelFKs.map((f) => [f.name, f]));
+        // Check for new or modified foreign keys
+        for (const modelFK of modelFKs) {
+            const dbFK = dbFKMap.get(modelFK.name);
+            if (!dbFK) {
+                changes.push({
+                    type: 'foreignKey',
+                    changeType: 'create',
+                    constraintName: modelFK.name,
+                    modelDefinition: modelFK,
+                });
+            }
+            else {
+                const changedProps = this.compareForeignKeyDefinitions(modelFK, dbFK);
+                if (changedProps.length > 0) {
+                    changes.push({
+                        type: 'foreignKey',
+                        changeType: 'modify',
+                        constraintName: modelFK.name,
+                        modelDefinition: modelFK,
+                        databaseDefinition: dbFK,
+                        changedProperties: changedProps,
+                    });
+                }
+            }
+        }
+        // Check for deleted foreign keys
+        for (const dbFK of dbFKs) {
+            if (!modelFKMap.has(dbFK.name)) {
+                changes.push({
+                    type: 'foreignKey',
+                    changeType: 'delete',
+                    constraintName: dbFK.name,
+                    databaseDefinition: dbFK,
+                });
+            }
+        }
+        return changes;
+    }
+    // ==================== Private Helper Methods ====================
+    /**
+     * Extract column definitions from model
+     */
+    extractColumnDefinitions(model) {
+        const rawAttributes = model.rawAttributes || {};
+        const columns = [];
+        for (const [attrName, attr] of Object.entries(rawAttributes)) {
+            const columnName = attr.field || attrName;
+            columns.push({
+                name: columnName,
+                type: attr.type,
+                typeString: this.serializeDataType(attr.type),
+                allowNull: attr.allowNull ?? true,
+                defaultValue: attr.defaultValue,
+                primaryKey: attr.primaryKey ?? false,
+                autoIncrement: attr.autoIncrement ?? false,
+                unique: (typeof attr.unique === 'object' ? false : attr.unique) ?? false,
+                references: attr.references
+                    ? {
+                        model: typeof attr.references.model === 'string'
+                            ? attr.references.model
+                            : attr.references.model.tableName || attr.references.model.name,
+                        key: attr.references.key || 'id',
+                        deferrable: attr.references.deferrable,
+                        onDelete: attr.references.onDelete,
+                        onUpdate: attr.references.onUpdate,
+                    }
+                    : undefined,
+                comment: attr.comment,
+                field: attr.field,
+            });
+        }
+        return columns;
+    }
+    /**
+     * Extract index definitions from model
+     */
+    extractIndexDefinitions(model) {
+        const indexes = model.indexes || [];
+        return indexes.map((idx) => ({
+            name: idx.name,
+            unique: idx.unique ?? false,
+            fields: idx.fields?.map((f) => (typeof f === 'string' ? f : f.attribute)) || [],
+        }));
+    }
+    /**
+     * Extract constraint definitions from model
+     */
+    extractConstraintDefinitions(model) {
+        const constraints = [];
+        const rawAttributes = model.rawAttributes || {};
+        // Extract primary key
+        const pkFields = [];
+        for (const [attrName, attr] of Object.entries(rawAttributes)) {
+            if (attr.primaryKey) {
+                pkFields.push(attr.field || attrName);
+            }
+        }
+        if (pkFields.length > 0) {
+            constraints.push({
+                name: `${model.tableName || model.name}_pkey`,
+                type: 'PRIMARY KEY',
+                fields: pkFields,
+            });
+        }
+        // Extract unique constraints from attributes
+        for (const [attrName, attr] of Object.entries(rawAttributes)) {
+            if (attr.unique && typeof attr.unique === 'string') {
+                constraints.push({
+                    name: attr.unique,
+                    type: 'UNIQUE',
+                    fields: [attr.field || attrName],
+                });
+            }
+        }
+        return constraints;
+    }
+    /**
+     * Extract foreign key definitions from model
+     */
+    extractForeignKeyDefinitions(model) {
+        const foreignKeys = [];
+        const rawAttributes = model.rawAttributes || {};
+        for (const [attrName, attr] of Object.entries(rawAttributes)) {
+            if (attr.references) {
+                const fieldName = attr.field || attrName;
+                const refModel = attr.references.model;
+                const refTable = typeof refModel === 'string' ? refModel : refModel.tableName || refModel.name;
+                foreignKeys.push({
+                    name: `${model.tableName || model.name}_${fieldName}_fkey`,
+                    fields: [fieldName],
+                    references: {
+                        table: refTable,
+                        fields: [attr.references.key || 'id'],
+                    },
+                });
+            }
+        }
+        return foreignKeys;
+    }
+    /**
+     * Get database column information
+     */
+    async getDatabaseColumns(tableName, schemaName) {
+        try {
+            const tableDesc = await this.dialect.describeTable(tableName);
+            return Object.entries(tableDesc).map(([name, col]) => ({
+                name,
+                type: col.type,
+                allowNull: col.allowNull,
+                defaultValue: col.defaultValue,
+                primaryKey: col.primaryKey,
+                autoIncrement: col.autoIncrement,
+            }));
+        }
+        catch {
+            // Table doesn't exist
+            return [];
+        }
+    }
+    /**
+     * Get database index information
+     */
+    async getDatabaseIndexes(tableName, _schemaName) {
+        try {
+            const indexes = await this.dialect.showIndexes(tableName);
+            return indexes.map((idx) => ({
+                name: idx.name,
+                unique: idx.unique ?? false,
+                type: idx.type,
+                fields: idx.fields?.map((f) => f.attribute || f.name || f) || [],
+                primary: idx.primary ?? false,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get database constraint information
+     */
+    async getDatabaseConstraints(tableName, _schemaName) {
+        try {
+            const constraints = await this.dialect.showConstraints(tableName);
+            return constraints.map((con) => ({
+                name: con.name,
+                type: con.type,
+                fields: con.fields,
+                check: con.check,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get database foreign key information
+     */
+    async getDatabaseForeignKeys(tableName, _schemaName) {
+        try {
+            const constraints = await this.dialect.showConstraints(tableName);
+            return constraints
+                .filter((con) => con.type === 'FOREIGN KEY')
+                .map((con) => ({
+                name: con.name,
+                fields: con.fields || [],
+                references: con.references || { table: '', fields: [] },
+                onDelete: con.onDelete,
+                onUpdate: con.onUpdate,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Serialize DataType to string for comparison
+     */
+    serializeDataType(type) {
+        if (!type)
+            return '';
+        if (typeof type === 'string')
+            return type;
+        const typeKey = type.key;
+        const typeArgs = type.values || [];
+        if (typeKey && typeArgs.length > 0) {
+            return `${typeKey.toUpperCase()}(${typeArgs.join(', ')})`;
+        }
+        return typeKey?.toUpperCase() || String(type);
+    }
+    /**
+     * Compare column definitions and return list of changed properties
+     */
+    compareColumnDefinitions(modelCol, dbCol) {
+        const changed = [];
+        // Compare types (simple comparison)
+        if (this.normalizeType(modelCol.typeString) !== this.normalizeType(dbCol.type)) {
+            changed.push('type');
+        }
+        // Compare nullability
+        if (modelCol.allowNull !== dbCol.allowNull) {
+            changed.push('allowNull');
+        }
+        // Compare default values
+        if (JSON.stringify(modelCol.defaultValue) !== JSON.stringify(dbCol.defaultValue)) {
+            changed.push('defaultValue');
+        }
+        // Compare primary key
+        if (modelCol.primaryKey !== dbCol.primaryKey) {
+            changed.push('primaryKey');
+        }
+        // Compare auto increment
+        if (modelCol.autoIncrement !== dbCol.autoIncrement) {
+            changed.push('autoIncrement');
+        }
+        return changed;
+    }
+    /**
+     * Compare index definitions and return list of changed properties
+     */
+    compareIndexDefinitions(modelIdx, dbIdx) {
+        const changed = [];
+        if (modelIdx.unique !== dbIdx.unique) {
+            changed.push('unique');
+        }
+        const modelFields = [...modelIdx.fields].sort().join(',');
+        const dbFields = [...dbIdx.fields].sort().join(',');
+        if (modelFields !== dbFields) {
+            changed.push('fields');
+        }
+        return changed;
+    }
+    /**
+     * Compare constraint definitions and return list of changed properties
+     */
+    compareConstraintDefinitions(modelCon, dbCon) {
+        const changed = [];
+        if (modelCon.type !== dbCon.type) {
+            changed.push('type');
+        }
+        const modelFields = [...(modelCon.fields || [])].sort().join(',');
+        const dbFields = [...(dbCon.fields || [])].sort().join(',');
+        if (modelFields !== dbFields) {
+            changed.push('fields');
+        }
+        return changed;
+    }
+    /**
+     * Compare foreign key definitions and return list of changed properties
+     */
+    compareForeignKeyDefinitions(modelFK, dbFK) {
+        const changed = [];
+        if (modelFK.references.table !== (dbFK.references?.table || '')) {
+            changed.push('references.table');
+        }
+        const modelRefFields = [...modelFK.references.fields].sort().join(',');
+        const dbRefFields = [...(dbFK.references?.fields || [])].sort().join(',');
+        if (modelRefFields !== dbRefFields) {
+            changed.push('references.fields');
+        }
+        return changed;
+    }
+    /**
+     * Normalize type string for comparison
+     */
+    normalizeType(typeStr) {
+        return typeStr.toUpperCase().replace(/\s+/g, ' ').trim();
+    }
+}
+exports.SchemaDiffer = SchemaDiffer;
+/**
+ * Create a SchemaDiffer instance
+ */
+function createSchemaDiffer(dialect, options) {
+    return new SchemaDiffer(dialect, options);
+}

package/dist/schema/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Schema Diff Types
+ * Type definitions for automated schema diffing and migration generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });