fiberx-backend-toolkit 0.0.61 → 0.0.62

package/dist/code_templates/sequelize_code_template.d.ts

@@ -1,7 +1,7 @@
-import { SchemaColumnInterface, SchemaDiffInterface } from "../types/schema_type";
+import { SchemaColumnInterface, SchemaDefinitionInterface, SchemaDiffInterface } from "../types/schema_type";
 declare const SEQUELIZE_SCHEMA_CODE_TEMPLATE: (schema_name: string, table_name: string, model_name: string, migration_priority: number) => string;
-declare const SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE: (schema_table_name: string, schema_model_name: string, schema_file_name: string) => string;
-declare const SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE: (schema_table_name: string, schema_model_name: string, diff: SchemaDiffInterface, schema_file_name: string) => string;
+declare const SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE: (schema_table_name: string, schema_model_name: string, schema_file_name: string, schema_definition: SchemaDefinitionInterface) => string;
+declare const SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE: (table_name: string, model_name: string, diff: SchemaDiffInterface, current_schema: SchemaDefinitionInterface, previous_schema: SchemaDefinitionInterface) => string;
 declare const SEQUELIZE_SEEDER_TEMPLATE: (class_name: string, table_name: string) => string;
 declare const SEQUELIZE_MODEL_CODE_TEMPLATE: (schema_model_name: string, schema_file_name: string, schema_columns: Record<string, SchemaColumnInterface>) => string;
 declare const SEQUELIZE_MODELS_INDEX_CODE_TEMPLATE: (model_names: string[], imports: string) => string;

package/dist/code_templates/sequelize_code_template.js

@@ -1,6 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SEQUELIZE_MODELS_INDEX_CODE_TEMPLATE = exports.SEQUELIZE_MODEL_CODE_TEMPLATE = exports.SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = exports.SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = exports.SEQUELIZE_SEEDER_TEMPLATE = exports.SEQUELIZE_SCHEMA_CODE_TEMPLATE = void 0;
+const serializeSequelizeDataType = (type) => {
+    if (!type)
+        return "undefined";
+    if (type.key) {
+        const key = type.key;
+        if (type.options?.length)
+            return `Sequelize.${key}(${type.options.length})`;
+        if (type.options?.values)
+            return `Sequelize.${key}(${JSON.stringify(type.options.values)})`;
+        if (type.options?.precision && type.options?.scale)
+            return `Sequelize.${key}(${type.options.precision}, ${type.options.scale})`;
+        return `Sequelize.${key}`;
+    }
+    return "undefined";
+};
+const serializeSequelizeColumnDefinition = (column) => {
+    const parts = [];
+    for (const [key, value] of Object.entries(column)) {
+        if (key === "type") {
+            parts.push(`type: ${serializeSequelizeDataType(value)}`);
+        }
+        else if (typeof value === "string") {
+            parts.push(`${key}: "${value}"`);
+        }
+        else if (typeof value === "boolean" || typeof value === "number") {
+            parts.push(`${key}: ${value}`);
+        }
+        else if (Array.isArray(value)) {
+            parts.push(`${key}: ${JSON.stringify(value)}`);
+        }
+        else if (value && typeof value === "object") {
+            parts.push(`${key}: ${JSON.stringify(value, null, 4)}`);
+        }
+    }
+    return `{
+        ${parts.join(",\n        ")}
+    }`;
+};
+const serializeIndexDefinition = (index) => {
+    const clone = { ...index };
+    delete clone.name;
+    return JSON.stringify(clone, null, 4);
+};
+const serializeSequelizeColumnsObject = (columns) => {
+    const rendered = Object.entries(columns)
+        .map(([col_name, col_Def]) => {
+        return `"${col_name}": ${serializeSequelizeColumnDefinition(col_Def)}`;
+    })
+        .join(",\n        ");
+    return `{
+        ${rendered}
+    }`;
+};
+const serializeSequelizeIndexesArray = (indexes) => {
+    return indexes.map(index => {
+        return `{
+            name: "${index.name}",
+            fields: ${JSON.stringify(index.fields)},
+            ${serializeIndexDefinition(index).replace(/^{|}$/g, "")}
+        }`;
+    }).join(",\n        ");
+};
 const SEQUELIZE_SCHEMA_CODE_TEMPLATE = (schema_name, table_name, model_name, migration_priority) => {
     return `
 import { DataTypes } from "sequelize";
@@ -47,239 +109,242 @@ export default ${schema_name};
 `;
 };
 exports.SEQUELIZE_SCHEMA_CODE_TEMPLATE = SEQUELIZE_SCHEMA_CODE_TEMPLATE;
-const SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = (schema_table_name, schema_model_name, schema_file_name) => `
+const SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = (schema_table_name, schema_model_name, schema_file_name, schema_definition) => {
+    const rendered_columns = serializeSequelizeColumnsObject(schema_definition.columns);
+    const rendered_indexes = serializeSequelizeIndexesArray(schema_definition.indexes || []);
+    return `
 import { QueryInterface, Sequelize } from "sequelize";
 import { LoggerUtil } from "fiberx-backend-toolkit/dist/utils/main";
-import { SchemaDefinitionInterface } from "fiberx-backend-toolkit";
-import ${schema_model_name}Schema from "@/database/schemas/${schema_file_name.replace(".ts", "")}";
 
 class Create${schema_model_name}TableMigration {
     private name: string = "create_table_${schema_table_name}_migration_file";
-    private schema: SchemaDefinitionInterface = ${schema_model_name}Schema;
     private readonly logger: LoggerUtil = new LoggerUtil(this.name);
 
     constructor() {}
 
-    // Migration UP
-    public async up(
-        queryInterface: QueryInterface, 
-        Sequelize: Sequelize
-    ) {
+    public async up(queryInterface: QueryInterface, Sequelize: Sequelize) {
         try {
-            const { table_name, model_name, columns = {}, indexes = [] } = this.schema;
-
-            await queryInterface.createTable(table_name, columns);
+            const table_name = "${schema_table_name}";
 
-            for (const index_field_obj of indexes) {
+            await queryInterface.createTable(
+                table_name,
+                ${rendered_columns}
+            );
 
-                const { fields, name, ...index_options } = index_field_obj;
-                const index_name = \`idx_\${table_name}_\${fields.join("_")}\`
-            
-                await queryInterface.addIndex(
-                    table_name, 
-                    fields, 
-                    { name: index_name, ...index_options }
-                );
-            }
+            ${schema_definition.indexes?.map(index => `
+            await queryInterface.addIndex(
+                table_name,
+                ${JSON.stringify(index.fields)},
+                {
+                    name: "${index.name}",
+                    ${serializeIndexDefinition(index).replace(/^{|}$/g, "")}
+                }
+            );
+            `).join("") || ""}
 
-            this.logger.success(\`✅ Table "\${table_name}" for schema "\${model_name}Schema" created with "\${indexes.length}" indexed Fields.\`);
+            this.logger.success(\`✅ Table "\${table_name}" created successfully.\`);
         } 
         catch (error: any) {
             this.logger.error(\`🚫 Migration failed: "\${error.message}"\`, { error });
-            throw new Error(\`🚫 Migration failed: "\${error.message}"\`);
+            throw error;
         }
     }
 
-    // Migration DOWN
-    public async down(
-        queryInterface: QueryInterface, 
-        Sequelize: Sequelize
-    ) {
+    public async down(queryInterface: QueryInterface, Sequelize: Sequelize) {
         try {
-            const { table_name, database_name, model_name } = this.schema;
-            await queryInterface.dropTable(table_name, {});
-            this.logger.success(\`🗑️ Table "\${table_name}" dropped successfully.\`);
+            await queryInterface.dropTable("${schema_table_name}");
+            this.logger.success(\`🗑️ Table "${schema_table_name}" dropped successfully.\`);
         } catch (error: any) {
-            this.logger.error(\`🚫 Migration rollback failed: "\${error.message}"\`, { error });
-            throw new Error(\`🚫 Migration rollback failed: "\${error.message}"\`);
+            this.logger.error(\`🚫 Rollback failed: "\${error.message}"\`, { error });
+            throw error;
         }
     }
 }
 
 export default Create${schema_model_name}TableMigration;
 `;
+};
 exports.SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE;
-const SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = (schema_table_name, schema_model_name, diff, schema_file_name) => `
+const SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = (table_name, model_name, diff, current_schema, previous_schema) => {
+    return `
 import { QueryInterface, Sequelize } from "sequelize";
 import { LoggerUtil } from "fiberx-backend-toolkit/dist/utils/main";
-import { SchemaDefinitionInterface } from "fiberx-backend-toolkit";
-import ${schema_model_name}Schema from "@/database/schemas/${schema_file_name.replace(".ts", "")}";
 
-class Update${schema_model_name}TableMigration {
-    private name: string = "update_table_${schema_table_name}_migration_file";
-    private schema: SchemaDefinitionInterface = ${schema_model_name}Schema;
+class Update${model_name}TableMigration {
+    private readonly name: string = "update_table_${table_name}_migration_file";
     private readonly logger: LoggerUtil = new LoggerUtil(this.name);
 
     constructor() {}
 
-    public async up(
-        queryInterface: QueryInterface, 
-        Sequelize: Sequelize
-    ) {
+    public async up(queryInterface: QueryInterface, Sequelize: Sequelize) {
         try {
-            const { table_name, model_name, columns = {}, indexes = [] } = this.schema;
+            let table_name = "${table_name}";
 
-        ${diff.table_renamed ? `
+            ${diff.table_renamed ? `
             await queryInterface.renameTable(
                 "${diff.table_renamed.from}",
                 "${diff.table_renamed.to}"
-            );`
-    :
-        ""}
+            );
+            table_name = "${diff.table_renamed.to}";
+            ` : ""}
 
-        // Add columns
-        ${diff.columns.added.map((column_name) => `
+            // ----------- ADD COLUMNS -----------
+            ${diff.columns.added.map(col => `
             await queryInterface.addColumn(
                 table_name,
-                "${column_name}",
-                columns["${column_name}"]
+                "${col}",
+                ${serializeSequelizeColumnDefinition(current_schema.columns[col])}
             );
-        `).join("")}
+            `).join("")}
 
-        // Modify columns
-        ${Object.entries(diff.columns.modified).map(([col_name, col_modified]) => `
+            // ----------- MODIFY COLUMNS -----------
+            ${diff.columns.modified.map(col => `
             await queryInterface.changeColumn(
-                table_name, 
-                "${col_name}", 
-                ${JSON.stringify(col_modified?.after)}
+                table_name,
+                "${col}",
+                ${serializeSequelizeColumnDefinition(current_schema.columns[col])}
             );
             `).join("")}
 
-        // Remove columns
-        ${Object.entries(diff.columns.modified).map(([col_name, col_Def]) => `
+            // ----------- REMOVE COLUMNS -----------
+            ${diff.columns.removed.map(col => `
             await queryInterface.removeColumn(
-                table_name, 
-                "${col_name}"
+                table_name,
+                "${col}"
             );
             `).join("")}
 
-
-        // Add indexes
-        ${diff.indexes.added.map((idx) => `
+            // ----------- ADD INDEXES -----------
+            ${diff.indexes.added.map(name => {
+        const curr_indxs = current_schema?.indexes || [];
+        const idx = curr_indxs.find(i => i.name === name);
+        return idx ? `
             await queryInterface.addIndex(
-                table_name, 
-                ${JSON.stringify(idx.fields)}, 
-                ${JSON.stringify(idx)}
+                table_name,
+                ${JSON.stringify(idx.fields)},
+                {
+                    name: "${idx.name}",
+                    ${serializeIndexDefinition(idx).replace(/^{|}$/g, "")}
+                }
             );
-            `).join("")}
+                ` : "";
+    }).join("")}
 
-        // Modify indexes (remove + add)
-        ${Object.entries(diff.indexes.modified).map(([idx_name, idx_modified]) => `
-            await queryInterface.removeIndex(
-                table_name, 
-                ${JSON.stringify(idx_modified.before.name)}
-            );
+            // ----------- MODIFY INDEXES -----------
+            ${diff.indexes.modified.map(name => {
+        const curr_indxs = current_schema?.indexes || [];
+        const idx = curr_indxs.find(i => i.name === name);
+        return idx ? `
+            await queryInterface.removeIndex(table_name, "${name}");
 
             await queryInterface.addIndex(
-                table_name, 
-                ${JSON.stringify(idx_modified.after.fields)}, 
-                ${JSON.stringify(idx_modified.after)}
+                table_name,
+                ${JSON.stringify(idx.fields)},
+                {
+                    name: "${idx.name}",
+                    ${serializeIndexDefinition(idx).replace(/^{|}$/g, "")}
+                }
             );
-            `).join("")}
+                ` : "";
+    }).join("")}
 
-        // Remove indexes
-        ${diff.indexes.removed.map((idx) => `
-            await queryInterface.removeIndex(
-                table_name, 
-                ${JSON.stringify(idx.name)}
-            );
+            // ----------- REMOVE INDEXES -----------
+            ${diff.indexes.removed.map(name => `
+            await queryInterface.removeIndex(table_name, "${name}");
             `).join("")}
 
-
-            this.logger.success(\`✅ Table "\${table_name}" for schema "\${model_name}Schema" updated successfully.\`);
+            this.logger.success(\`✅ Table "\${table_name}" updated successfully.\`);
         } 
         catch (error: any) {
             this.logger.error(\`🚫 Update migration failed: "\${error.message}"\`, { error });
-            throw new Error(\`🚫 Update migration failed: "\${error.message}"\`);
+            throw error;
         }
     }
 
-    public async down(
-        queryInterface: QueryInterface, 
-        Sequelize: Sequelize
-    ) {
+    public async down(queryInterface: QueryInterface, Sequelize: Sequelize) {
         try {
-            const { table_name, model_name, columns = {} } = this.schema;
-
-        // Revert Added indexes
-        ${diff.indexes.added.map((idx) => `
-            await queryInterface.removeIndex(
-                table_name, 
-                ${JSON.stringify(idx.name)}
-            );`).join("")}
-
-        // Revert Modified Indexes
-        ${Object.entries(diff.indexes.modified).map(([idx_name, idx_modified]) => `
-            await queryInterface.removeIndex(
-                table_name, 
-                ${JSON.stringify(idx_modified.after.name)}
-            );
+            let table_name = "${table_name}";
 
+            // ----------- REVERT INDEXES -----------
+            ${diff.indexes.added.map(name => `
+            await queryInterface.removeIndex(table_name, "${name}");
+            `).join("")}
+
+            ${diff.indexes.modified.map(name => {
+        const prev_indxs = previous_schema?.indexes || [];
+        const idx = prev_indxs.find(i => i.name === name);
+        return idx ? `
+            await queryInterface.removeIndex(table_name, "${name}");
 
             await queryInterface.addIndex(
-                table_name, 
-                ${JSON.stringify(idx_modified.before.fields)}, 
-                ${JSON.stringify(idx_modified.before)}
-            );`).join("")}
+                table_name,
+                ${JSON.stringify(idx.fields)},
+                {
+                    name: "${idx.name}",
+                    ${serializeIndexDefinition(idx).replace(/^{|}$/g, "")}
+                }
+            );
+                ` : "";
+    }).join("")}
 
-        // Revert removed indexes
-        ${diff.indexes.removed.map((idx) => `
+            ${diff.indexes.removed.map(name => {
+        const prev_indxs = previous_schema?.indexes || [];
+        const idx = prev_indxs.find(i => i.name === name);
+        return idx ? `
             await queryInterface.addIndex(
-                table_name, 
-                ${JSON.stringify(idx.fields)}, 
-                ${JSON.stringify(idx)}
-            );`).join("")}
+                table_name,
+                ${JSON.stringify(idx.fields)},
+                {
+                    name: "${idx.name}",
+                    ${serializeIndexDefinition(idx).replace(/^{|}$/g, "")}
+                }
+            );
+                ` : "";
+    }).join("")}
 
-        // Revert Modified columns
-        ${Object.entries(diff.columns.modified).map(([col_name, col_modified]) => `
+            // ----------- REVERT COLUMNS -----------
+            ${diff.columns.modified.map(col => `
             await queryInterface.changeColumn(
-                table_name, 
-                "${col_name}", 
-                ${JSON.stringify(col_modified.before)}
-            );`).join("")}
+                table_name,
+                "${col}",
+                ${serializeSequelizeColumnDefinition(previous_schema.columns[col])}
+            );
+            `).join("")}
 
-        // Revert added columns
-        ${diff.columns.added.map((column_name) => `
-            await queryInterface.removeColumn(table_name, "${column_name}");
-        `).join("")}
+            ${diff.columns.added.map(col => `
+            await queryInterface.removeColumn(table_name, "${col}");
+            `).join("")}
 
-        ${Object.entries(diff.columns.modified).map(([col_name, col_Def]) => `
+            ${diff.columns.removed.map(col => `
             await queryInterface.addColumn(
-                table_name, 
-                "${col_name}", 
-                ${JSON.stringify(col_Def)}
+                table_name,
+                "${col}",
+                ${serializeSequelizeColumnDefinition(previous_schema.columns[col])}
             );
-        `).join("")}
+            `).join("")}
 
-        ${diff.table_renamed ? `
+            ${diff.table_renamed ? `
             await queryInterface.renameTable(
                 "${diff.table_renamed.to}",
                 "${diff.table_renamed.from}"
-            );` : ""}
+            );
+            ` : ""}
 
-            this.logger.success(\`🗑️ Rollback of table "\${table_name}" completed successfully.\`);
+            this.logger.success(\`🗑️ Rollback completed successfully.\`);
         } 
         catch (error: any) {
             this.logger.error(\`🚫 Rollback migration failed: "\${error.message}"\`, { error });
-            throw new Error(\`🚫 Rollback migration failed: "\${error.message}"\`);
+            throw error;
         }
     }
 }
 
-export default Update${schema_model_name}TableMigration;
+export default Update${model_name}TableMigration;
 `;
+};
 exports.SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE;
-const SEQUELIZE_SEEDER_TEMPLATE = (class_name, table_name) => `
+const SEQUELIZE_SEEDER_TEMPLATE = (class_name, table_name) => {
+    return `
 'use strict';
 
 import { QueryInterface } from 'sequelize';
@@ -324,6 +389,7 @@ class ${class_name}Seeder {
 
 export default  ${class_name}Seeder;
 `;
+};
 exports.SEQUELIZE_SEEDER_TEMPLATE = SEQUELIZE_SEEDER_TEMPLATE;
 const SEQUELIZE_MODEL_CODE_TEMPLATE = (schema_model_name, schema_file_name, schema_columns) => {
     const attributes = Object.keys(schema_columns)
@@ -349,7 +415,7 @@ ${attributes}
             ${schema_model_name}Schema.columns,
             {
                 sequelize,
-                tableName: ${schema_model_name}Schema.table_name,
+                table_name: ${schema_model_name}Schema.table_name,
                 modelName: ${schema_model_name}Schema.model_name,
                 timestamps: ${schema_model_name}Schema.timestamps,
                 indexes: ${schema_model_name}Schema.indexes,

package/dist/database/schema/schema_diff_util.js

@@ -1,5 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const input_validator_util_1 = __importDefault(require("../../utils/input_validator_util"));
 class SchemaDiffUtil {
     static indexKey(i) {
         return JSON.stringify({
@@ -11,8 +15,8 @@ class SchemaDiffUtil {
     }
     static getSchemaDifference(prev, curr) {
         const diff = {
-            columns: { added: [], removed: {}, modified: {} },
-            indexes: { added: [], removed: [], modified: {} },
+            columns: { added: [], removed: [], modified: [] },
+            indexes: { added: [], removed: [], modified: [] }
         };
         // Table rename
         if (prev.table_name !== curr.table_name) {
@@ -22,46 +26,39 @@ class SchemaDiffUtil {
             };
         }
         // Columns
-        for (const [col_name, col_def] of Object.entries(curr.columns)) {
-            const prev_col = prev.columns[col_name];
-            if (!prev_col) {
+        const prev_cols = prev.columns;
+        const curr_cols = curr.columns;
+        for (const [col_name, col_def] of Object.entries(curr_cols)) {
+            const prev_col_def = prev_cols[col_name];
+            if (!prev_col_def) {
                 diff.columns.added.push(col_name);
             }
-            else if (JSON.stringify(prev_col) !== JSON.stringify(col_def)) {
-                diff.columns.modified[col_name] = {
-                    before: prev_col,
-                    after: col_def
-                };
+            else if (!input_validator_util_1.default.isDeepEqual(prev_col_def, col_def)) {
+                diff.columns.modified.push(col_name);
             }
         }
-        for (const [prev_col_name, prev_col_def] of Object.entries(prev.columns)) {
-            if (!curr.columns[prev_col_name]) {
-                diff.columns.removed[prev_col_name] = prev_col_def;
+        for (const col_name of Object.keys(prev_cols)) {
+            if (!curr_cols[col_name]) {
+                diff.columns.removed.push(col_name);
             }
         }
         // Indexes
         const prev_indexes = prev?.indexes || [];
         const curr_indexes = curr?.indexes || [];
-        const prev_map = new Map(prev_indexes.map(i => [SchemaDiffUtil.indexKey(i), i]));
-        const curr_map = new Map(curr_indexes.map(i => [SchemaDiffUtil.indexKey(i), i]));
-        for (const [key, idx] of curr_map) {
-            if (!prev_map.has(key)) {
-                diff.indexes.added.push(idx);
+        const prev_map = new Map(prev_indexes.map(i => [i.name, i]));
+        const curr_map = new Map(curr_indexes.map(i => [i.name, i]));
+        for (const [name, curr_idx] of curr_map) {
+            const prev_idx = prev_map.get(name);
+            if (!prev_idx) {
+                diff.indexes.added.push(name);
             }
-        }
-        for (const [key, idx] of prev_map) {
-            if (!curr_map.has(key)) {
-                diff.indexes.removed.push(idx);
+            else if (!input_validator_util_1.default.isDeepEqual(prev_idx, curr_idx)) {
+                diff.indexes.modified.push(name);
             }
         }
-        // Modified indexes (same fields, different options)
-        for (const curr_idx of curr_indexes) {
-            const prev_idx = prev_indexes.find(p => JSON.stringify([...p.fields].sort()) === JSON.stringify([...curr_idx.fields].sort()));
-            if (prev_idx && JSON.stringify(prev_idx) !== JSON.stringify(curr_idx)) {
-                diff.indexes.modified[curr_idx?.name] = {
-                    before: prev_idx,
-                    after: curr_idx
-                };
+        for (const [name] of prev_map) {
+            if (!curr_map.has(name)) {
+                diff.indexes.removed.push(name);
             }
         }
         return diff;

package/dist/database/schema/schema_normalizer_util.d.ts

@@ -2,7 +2,7 @@ import { SchemaDefinitionInterface, SchemaSnapshotInterface } from "../../types/
 declare class SchemaNormalizerUtil {
     static normalizeColumn(column: any): {
         type: any;
-        allow_null: any;
+        allowNull: any;
         primary_key: boolean;
         auto_increment: boolean;
         unique: boolean;

package/dist/database/schema/schema_normalizer_util.js

@@ -4,7 +4,7 @@ class SchemaNormalizerUtil {
     static normalizeColumn(column) {
         return {
             type: column.type?.key ?? column.type?.toString(),
-            allow_null: column.allowNull ?? true,
+            allowNull: column.allowNull ?? true,
             primary_key: !!column.primaryKey,
             auto_increment: !!column.autoIncrement,
             unique: !!column.unique,

package/dist/database/scripts/make_migrations_script.js

@@ -17,7 +17,7 @@ class MakeMigrationsScript {
     logger = new main_1.LoggerUtil(this.name);
     constructor() { }
     getSnapshotPath(model_name) {
-        return path_1.default.join(this.snapshot_dir, `${main_1.InputTransformerUtil.toSnakeCase(model_name)}.schema_snapshot.json`);
+        return path_1.default.join(this.snapshot_dir, `${main_1.InputTransformerUtil.toSnakeCase(model_name)}.schema_snapshot.ts`);
     }
     // Method to handle generating migration file name
     generateMigrationFilename(table_name, type, migration_priority) {
@@ -26,13 +26,14 @@ class MakeMigrationsScript {
     }
     ;
     // Methos to write schema snapshot
-    writeSchemaSnapshot(model_name, normalized_schema) {
+    writeSchemaSnapshot(model_name, schema_file_path) {
         const snapshot_path = this.getSnapshotPath(model_name);
         try {
             // Ensure snapshot directory exists
             main_1.InputValidatorUtil.dirExists(this.snapshot_dir, true);
-            fs_1.default.writeFileSync(snapshot_path, JSON.stringify(normalized_schema, null, 2), { encoding: "utf-8" });
-            this.logger.success(`📸 Schema snapshot saved: ${snapshot_path}`);
+            // Copy schema file exactly as-is
+            fs_1.default.copyFileSync(schema_file_path, snapshot_path);
+            this.logger.success(`📸 Schema snapshot copied to: ${snapshot_path}`);
             return true;
         }
         catch (error) {
@@ -42,10 +43,10 @@ class MakeMigrationsScript {
         }
     }
     // Method to handle create update schema table migration file
-    createUpdateSchemaMigrationFile(file_path, schema_file_path, schema_content, schema_diff) {
+    createUpdateSchemaMigrationFile(file_path, schema_file_path, schema_content, prev_schema_content, schema_diff) {
         const { table_name, model_name } = schema_content;
         const schema_file_name = path_1.default.basename(schema_file_path);
-        const template = (0, sequelize_code_template_1.SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE)(table_name, model_name, schema_diff, schema_file_name);
+        const template = (0, sequelize_code_template_1.SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE)(table_name, model_name, schema_diff, schema_content, prev_schema_content);
         try {
             fs_1.default.writeFileSync(file_path, template, { encoding: "utf-8" });
         }
@@ -59,7 +60,7 @@ class MakeMigrationsScript {
     createNewSchemaMigrationFile(file_path, schema_file_path, schema_content) {
         const { table_name, model_name } = schema_content;
         const schema_file_name = path_1.default.basename(schema_file_path);
-        const template = (0, sequelize_code_template_1.SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE)(table_name, model_name, schema_file_name);
+        const template = (0, sequelize_code_template_1.SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE)(table_name, model_name, schema_file_name, schema_content);
         try {
             fs_1.default.writeFileSync(file_path, template, { encoding: "utf-8" });
         }
@@ -77,7 +78,6 @@ class MakeMigrationsScript {
             this.logger.error(`❌ Schema has no table_name: ${schema_file_path}`);
             return;
         }
-        const normalized_schema = main_2.SchemaNormalizerUtil.normalizeSchema(schema_content);
         const snapshot_path = this.getSnapshotPath(model_name);
         const operation = !fs_1.default.existsSync(snapshot_path) ? "create" : "update";
         const migration_file_name = this.generateMigrationFilename(table_name, operation, migration_priority);
@@ -90,8 +90,9 @@ class MakeMigrationsScript {
         else {
             // Existing migration → UPDATE
             this.logger.info(`🔄 Found existing migration snapshots: ${snapshot_path} → checking for updates...`);
-            const previous_snapshot = JSON.parse(fs_1.default.readFileSync(snapshot_path, "utf-8"));
-            const diff = main_2.SchemaDiffUtil.getSchemaDifference(previous_snapshot, normalized_schema);
+            delete require.cache[require.resolve(snapshot_path)];
+            const previous_snapshot = require(snapshot_path).default;
+            const diff = main_2.SchemaDiffUtil.getSchemaDifference(previous_snapshot, schema_content);
             if (!diff.table_renamed &&
                 !diff.columns.added.length &&
                 !diff.columns.removed.length &&
@@ -101,12 +102,12 @@ class MakeMigrationsScript {
                 this.logger.info("ℹ️ No schema changes detected");
                 return false;
             }
-            migration_file_created = this.createUpdateSchemaMigrationFile(migration_file_path, schema_file_path, schema_content, diff);
+            migration_file_created = this.createUpdateSchemaMigrationFile(migration_file_path, schema_file_path, schema_content, previous_snapshot, diff);
         }
         if (migration_file_created) {
             this.logger.success(`✅ Migration file created: ${migration_file_name}`);
             // Update snapshot AFTER successful migration creation
-            const snapshot_written = this.writeSchemaSnapshot(model_name, normalized_schema);
+            const snapshot_written = this.writeSchemaSnapshot(model_name, schema_file_path);
             if (!snapshot_written) {
                 this.logger.error(`⚠️ Migration created but snapshot update failed for "${model_name}"`);
             }

package/dist/types/schema_type.d.ts

@@ -69,18 +69,12 @@ export interface SchemaDiffInterface {
     };
     columns: {
         added: string[];
-        removed: Record<string, SchemaColumnInterface>;
-        modified: Record<string, {
-            before: SchemaColumnInterface;
-            after: SchemaColumnInterface;
-        }>;
+        removed: string[];
+        modified: string[];
     };
     indexes: {
-        added: IndexFieldOptionsInterface[];
-        removed: IndexFieldOptionsInterface[];
-        modified: Record<string, {
-            before: IndexFieldOptionsInterface;
-            after: IndexFieldOptionsInterface;
-        }>;
+        added: string[];
+        removed: string[];
+        modified: string[];
     };
 }

package/dist/utils/input_validator_util.d.ts

@@ -50,5 +50,6 @@ declare class InputValidatorUtil {
     static isValidReCaptcha(recpatcha_token: string): Promise<any>;
     static dirExists(directory: string, create_directory?: boolean, return_dir_path?: boolean): boolean | string;
     static isSafeHashCompare(a: string, b: string): boolean;
+    static isDeepEqual(a: any, b: any): boolean;
 }
 export default InputValidatorUtil;

package/dist/utils/input_validator_util.js

@@ -125,5 +125,54 @@ class InputValidatorUtil {
         }
         return crypto_1.default.timingSafeEqual(buf1, buf2);
     }
+    static isDeepEqual(a, b) {
+        // Strict equal handles primitives + same reference
+        if (a === b)
+            return true;
+        // Handle null / undefined
+        if (a == null || b == null)
+            return a === b;
+        // Handle Date
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
+        // Handle functions (compare source)
+        if (typeof a === "function" && typeof b === "function") {
+            return a.toString() === b.toString();
+        }
+        // Handle Sequelize DataTypes
+        if (a?.key && b?.key) {
+            if (a.key !== b.key)
+                return false;
+            const aOpts = a.options || {};
+            const bOpts = b.options || {};
+            return InputValidatorUtil.isDeepEqual(aOpts, bOpts);
+        }
+        // Handle arrays
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (!InputValidatorUtil.isDeepEqual(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        // Handle objects
+        if (typeof a === "object" && typeof b === "object") {
+            const aKeys = Object.keys(a);
+            const bKeys = Object.keys(b);
+            if (aKeys.length !== bKeys.length)
+                return false;
+            for (const key of aKeys) {
+                if (!bKeys.includes(key))
+                    return false;
+                if (!InputValidatorUtil.isDeepEqual(a[key], b[key]))
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
 }
 exports.default = InputValidatorUtil;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fiberx-backend-toolkit",
-    "version": "0.0.61",
+    "version": "0.0.62",
     "description": "A TypeScript backend toolkit providing shared domain logic, infrastructure helpers, and utilities for FiberX server-side applications and services.",
     "type": "commonjs",
     "main": "./dist/index.js",