fiberx-backend-toolkit 0.1.21 → 1.0.3

package/dist/database/connectors/sequelize_connector.js

@@ -35,18 +35,32 @@ class SequelizeConnector extends base_connector_1.default {
             this.logger.error("Failed to log SQL query", { error });
         }
     };
+    coerceBoolean(value, fallback) {
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "string") {
+            return ["true", "1", "yes", "on"].includes(value.trim().toLowerCase());
+        }
+        if (typeof value === "number")
+            return value === 1;
+        return fallback;
+    }
+    coerceNumber(value, fallback) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : fallback;
+    }
     // ------------------------------------------------
     // Create Sequelize instance (shared)
     // ------------------------------------------------
     createSequelizeInstance(options = {}) {
         const dialect = options.dialect ?? this.env_manager.getEnvVar("DB_DIALECT", "postgres");
-        const logging_enabled = options.logging ?? this.env_manager.getEnvVar("DB_LOGGING", false);
+        const logging_enabled = this.coerceBoolean(options.logging ?? this.env_manager.getEnvVar("DB_LOGGING", false), false);
         const logging = logging_enabled ? this.formatSQLQueryLog : false;
         const database = options.database ?? this.env_manager.getEnvVar("DB_NAME");
         const username = options.username ?? this.env_manager.getEnvVar("DB_USER");
         const password = options.password ?? this.env_manager.getEnvVar("DB_PASSWORD");
         const host = options.host ?? this.env_manager.getEnvVar("DB_HOST");
-        const port = options.port ?? this.env_manager.getEnvVar("DB_PORT", 5432);
+        const port = this.coerceNumber(options.port ?? this.env_manager.getEnvVar("DB_PORT", 5432), 5432);
         return new sequelize_1.Sequelize({
             database,
             username,
@@ -79,28 +93,36 @@ class SequelizeConnector extends base_connector_1.default {
                 dialect,
                 logging: false,
             });
-            await admin.authenticate();
-            switch (dialect) {
-                case "postgres": {
-                    const [rows] = await admin.query(`SELECT 1 FROM pg_database WHERE datname = :db`, { replacements: { db: database } });
-                    if (rows.length === 0) {
-                        await admin.query(`CREATE DATABASE "${database}"`);
-                        this.logger.info(`📦 Created DB ${database}`);
+            try {
+                await admin.authenticate();
+                const queryInterface = admin.getQueryInterface();
+                const quoted_database = queryInterface.quoteIdentifier(database);
+                switch (dialect) {
+                    case "postgres": {
+                        const [rows] = await admin.query(`SELECT 1 FROM pg_database WHERE datname = :db`, { replacements: { db: database } });
+                        if (rows.length === 0) {
+                            await admin.query(`CREATE DATABASE ${quoted_database}`);
+                            this.logger.info(`📦 Created DB ${database}`);
+                        }
+                        break;
+                    }
+                    case "mysql":
+                    case "mariadb":
+                        await admin.query(`CREATE DATABASE IF NOT EXISTS ${quoted_database}`);
+                        break;
+                    case "mssql": {
+                        const escaped_database = database.replace(/'/g, "''");
+                        await admin.query(`
+                            IF DB_ID('${escaped_database}') IS NULL
+                            CREATE DATABASE ${quoted_database}
+                        `);
+                        break;
                     }
-                    break;
                 }
-                case "mysql":
-                case "mariadb":
-                    await admin.query(`CREATE DATABASE IF NOT EXISTS \`${database}\``);
-                    break;
-                case "mssql":
-                    await admin.query(`
-                        IF DB_ID('${database}') IS NULL
-                        CREATE DATABASE [${database}]
-                    `);
-                    break;
             }
-            await admin.close();
+            finally {
+                await admin.close();
+            }
         }
         catch (error) {
             this.logger.error(`DB auto-create skipped: ${database}`, { error });

package/dist/database/main.d.ts

@@ -5,7 +5,8 @@ import MakeMigrationsScript from "./scripts/make_migrations_script";
 import MigrationRunnerScript from "./scripts/migration_runner_script";
 import CreateSeederScript from "./scripts/create_seeder_script";
 import SeederRunnerScript from "./scripts/seeder_runner_script";
-import SeqeulizeModelGeneratorScript from "./scripts/sequelize_model_generator_script";
+import SequelizeModelGeneratorScript from "./scripts/sequelize_model_generator_script";
+declare const SeqeulizeModelGeneratorScript: typeof SequelizeModelGeneratorScript;
 import BaseConnector from "./connectors/base_connector";
 import SequelizeConnector from "./connectors/sequelize_connector";
-export { SchemaDiffUtil, SchemaNormalizerUtil, CreateSchemaScript, MakeMigrationsScript, MigrationRunnerScript, CreateSeederScript, SeederRunnerScript, SeqeulizeModelGeneratorScript, BaseConnector, SequelizeConnector };
+export { SchemaDiffUtil, SchemaNormalizerUtil, CreateSchemaScript, MakeMigrationsScript, MigrationRunnerScript, CreateSeederScript, SeederRunnerScript, SequelizeModelGeneratorScript, SeqeulizeModelGeneratorScript, BaseConnector, SequelizeConnector, };

package/dist/database/main.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SequelizeConnector = exports.BaseConnector = exports.SeqeulizeModelGeneratorScript = exports.SeederRunnerScript = exports.CreateSeederScript = exports.MigrationRunnerScript = exports.MakeMigrationsScript = exports.CreateSchemaScript = exports.SchemaNormalizerUtil = exports.SchemaDiffUtil = void 0;
+exports.SequelizeConnector = exports.BaseConnector = exports.SeqeulizeModelGeneratorScript = exports.SequelizeModelGeneratorScript = exports.SeederRunnerScript = exports.CreateSeederScript = exports.MigrationRunnerScript = exports.MakeMigrationsScript = exports.CreateSchemaScript = exports.SchemaNormalizerUtil = exports.SchemaDiffUtil = void 0;
 const schema_diff_util_1 = __importDefault(require("./schema/schema_diff_util"));
 exports.SchemaDiffUtil = schema_diff_util_1.default;
 const schema_normalizer_util_1 = __importDefault(require("./schema/schema_normalizer_util"));
@@ -19,7 +19,9 @@ exports.CreateSeederScript = create_seeder_script_1.default;
 const seeder_runner_script_1 = __importDefault(require("./scripts/seeder_runner_script"));
 exports.SeederRunnerScript = seeder_runner_script_1.default;
 const sequelize_model_generator_script_1 = __importDefault(require("./scripts/sequelize_model_generator_script"));
-exports.SeqeulizeModelGeneratorScript = sequelize_model_generator_script_1.default;
+exports.SequelizeModelGeneratorScript = sequelize_model_generator_script_1.default;
+const SeqeulizeModelGeneratorScript = sequelize_model_generator_script_1.default;
+exports.SeqeulizeModelGeneratorScript = SeqeulizeModelGeneratorScript;
 const base_connector_1 = __importDefault(require("./connectors/base_connector"));
 exports.BaseConnector = base_connector_1.default;
 const sequelize_connector_1 = __importDefault(require("./connectors/sequelize_connector"));

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

@@ -1,6 +1,5 @@
 import { SchemaDiffInterface, SchemaSnapshotInterface } from "../../types/schema_type";
 declare class SchemaDiffUtil {
-    private static indexKey;
     static getSchemaDifference(prev: SchemaSnapshotInterface, curr: SchemaSnapshotInterface): SchemaDiffInterface;
 }
 export default SchemaDiffUtil;

package/dist/database/schema/schema_diff_util.js

@@ -5,18 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (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({
-            fields: i.fields,
-            unique: i.unique,
-            using: i.using,
-            operator: i.operator,
-        });
-    }
     static getSchemaDifference(prev, curr) {
         const diff = {
             columns: { added: [], removed: [], modified: [] },
-            indexes: { added: [], removed: [], modified: [] }
+            indexes: { added: [], removed: [], modified: [] },
         };
         // Table rename
         if (prev.table_name !== curr.table_name) {
@@ -45,10 +37,10 @@ class SchemaDiffUtil {
         // 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, curr_idx] of curr_map) {
-            const prev_idx = prev_map.get(key);
+        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(curr_idx.name);
             }
@@ -56,8 +48,8 @@ class SchemaDiffUtil {
                 diff.indexes.modified.push(curr_idx.name);
             }
         }
-        for (const [key, prev_idx] of prev_map) {
-            if (!curr_map.has(key)) {
+        for (const [name, prev_idx] of prev_map) {
+            if (!curr_map.has(name)) {
                 diff.indexes.removed.push(prev_idx.name);
             }
         }

package/dist/database/scripts/create_schema_script.js

@@ -57,8 +57,12 @@ class CreateSchemaScript {
     run() {
         const file_base_name = main_1.InputTransformerUtil.toSchemaFileName(this.raw_input);
         const base_pascal = main_1.InputTransformerUtil.toPascalCase(file_base_name);
-        const schema_name = base_pascal.toLowerCase().endsWith("schema") ? base_pascal : `${base_pascal}Schema`;
-        const model_name = base_pascal.toLowerCase().endsWith("schema") ? base_pascal.replace(/Schema$/i, "") : base_pascal;
+        const schema_name = base_pascal.toLowerCase().endsWith("schema")
+            ? base_pascal
+            : `${base_pascal}Schema`;
+        const model_name = base_pascal.toLowerCase().endsWith("schema")
+            ? base_pascal.replace(/Schema$/i, "")
+            : base_pascal;
         const table_name = main_1.InputTransformerUtil.pluralizeSnakeCase(main_1.InputTransformerUtil.toSnakeCase(model_name));
         const migration_priority = this.getNextMigrationPriority();
         const file_name = `${file_base_name}.ts`;
@@ -67,7 +71,6 @@ class CreateSchemaScript {
         main_1.InputValidatorUtil.dirExists(this.schemas_dir, true);
         this.ensureSchemaDoesNotExist(file_path);
         this.createSchemaFile(file_path, schema_name, model_name, table_name, migration_priority);
-        ;
         this.logger.success(`✅ Schema created successfully Created database/schemas/${file_base_name}.ts`);
         this.logger.info(`📄 File Path: ${file_path}`);
         this.logger.info(`🧩 Schema Name: ${schema_name}`);

package/dist/database/scripts/make_migrations_script.js

@@ -21,10 +21,12 @@ class MakeMigrationsScript {
     }
     // Method to handle generating migration file name
     generateMigrationFilename(table_name, type, migration_priority) {
-        const timestamp = new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14);
+        const timestamp = new Date()
+            .toISOString()
+            .replace(/[-:.TZ]/g, "")
+            .slice(0, 14);
         return `${migration_priority}_${timestamp}_${type}_table_${table_name}.ts`;
     }
-    ;
     // Methos to write schema snapshot
     writeSchemaSnapshot(model_name, schema_file_path) {
         const snapshot_path = this.getSnapshotPath(model_name);
@@ -43,9 +45,8 @@ class MakeMigrationsScript {
         }
     }
     // Method to handle create update schema table migration file
-    createUpdateSchemaMigrationFile(file_path, schema_file_path, schema_content, prev_schema_content, schema_diff) {
+    createUpdateSchemaMigrationFile(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_content, prev_schema_content);
         try {
             fs_1.default.writeFileSync(file_path, template, { encoding: "utf-8" });
@@ -73,9 +74,12 @@ class MakeMigrationsScript {
     // Method to handle creating migration files for new and updated schemas
     createMigrationForSchema(schema_file_path, schema_content) {
         this.logger.info(`💾 Ready to create migration for: ${schema_file_path}`);
-        const { table_name, migration_priority, model_name, } = schema_content;
-        if (!table_name) {
-            this.logger.error(`❌ Schema has no table_name: ${schema_file_path}`);
+        const { table_name, migration_priority, model_name } = schema_content;
+        if (!table_name ||
+            !model_name ||
+            !schema_content.columns ||
+            !Number.isFinite(Number(migration_priority))) {
+            this.logger.error(`❌ Schema is missing table_name, model_name, migration_priority, or columns: ${schema_file_path}`);
             return;
         }
         const snapshot_path = this.getSnapshotPath(model_name);
@@ -98,11 +102,12 @@ class MakeMigrationsScript {
                 !diff.columns.removed.length &&
                 !Object.keys(diff.columns.modified).length &&
                 !diff.indexes.added.length &&
-                !diff.indexes.removed.length) {
+                !diff.indexes.removed.length &&
+                !diff.indexes.modified.length) {
                 this.logger.info("ℹ️ No schema changes detected");
                 return false;
             }
-            migration_file_created = this.createUpdateSchemaMigrationFile(migration_file_path, schema_file_path, schema_content, previous_snapshot, diff);
+            migration_file_created = this.createUpdateSchemaMigrationFile(migration_file_path, schema_content, previous_snapshot, diff);
         }
         if (migration_file_created) {
             this.logger.success(`✅ Migration file created: ${migration_file_name}`);
@@ -124,7 +129,9 @@ class MakeMigrationsScript {
         main_1.InputValidatorUtil.dirExists(this.schemas_dir, true);
         main_1.InputValidatorUtil.dirExists(this.migrations_dir, true);
         // Fetch all TypeScript schema files
-        const schema_files = fs_1.default.readdirSync(this.schemas_dir).filter(file => file.endsWith(".ts"));
+        const schema_files = fs_1.default
+            .readdirSync(this.schemas_dir)
+            .filter((file) => file.endsWith(".ts"));
         if (!schema_files.length) {
             this.logger.info("⚠️ No schema files found.");
             return;

package/dist/database/scripts/migration_runner_script.d.ts

@@ -4,9 +4,11 @@ declare class MigrationRunnerScript {
     private readonly migrations_dir;
     private readonly db_connection;
     private readonly logger;
-    private readonly sequelize_instance;
+    private sequelize_instance?;
     constructor();
     private getMigrationFiles;
+    private getSequelizeInstance;
+    private normalizeTableName;
     private ensureMetaTable;
     private getAppliedMigrations;
     private applyMigration;

package/dist/database/scripts/migration_runner_script.js

@@ -17,39 +17,63 @@ class MigrationRunnerScript {
     sequelize_instance;
     constructor() {
         main_2.InputValidatorUtil.dirExists(this.migrations_dir, true);
-        this.sequelize_instance = this.db_connection.connectSync();
     }
     // Fetch all migration files
     getMigrationFiles(schema_name) {
-        const files = fs_1.default.readdirSync(this.migrations_dir).filter(f => f.endsWith(".ts"));
+        const files = fs_1.default.readdirSync(this.migrations_dir).filter((file) => {
+            if (file.endsWith(".d.ts"))
+                return false;
+            return file.endsWith(".ts") || file.endsWith(".js");
+        });
         if (schema_name) {
-            return files.filter(f => f.toLowerCase().includes(schema_name.toLowerCase()));
+            return files.filter((f) => f.toLowerCase().includes(schema_name.toLowerCase()));
         }
         return files;
     }
+    async getSequelizeInstance() {
+        if (!this.sequelize_instance) {
+            this.sequelize_instance = await this.db_connection.connect();
+        }
+        return this.sequelize_instance;
+    }
+    normalizeTableName(table) {
+        if (typeof table === "string")
+            return table;
+        if (table && typeof table === "object") {
+            const table_obj = table;
+            return table_obj.tableName ?? table_obj.table_name ?? table_obj.name ?? "";
+        }
+        return "";
+    }
     // Ensure SequelizeMeta table exists
     async ensureMetaTable() {
-        const queryInterface = this.sequelize_instance.getQueryInterface();
-        const table_names = await queryInterface.showAllTables();
+        const sequelize = await this.getSequelizeInstance();
+        const queryInterface = sequelize.getQueryInterface();
+        const table_names = (await queryInterface.showAllTables()).map((table) => this.normalizeTableName(table));
         if (!table_names.includes(constants_1.SEQUELIZE_META_TABLE_NAME)) {
             this.logger.info("⏳ Creating SequelizeMeta table...");
             await queryInterface.createTable(constants_1.SEQUELIZE_META_TABLE_NAME, {
                 name: {
                     type: sequelize_1.DataTypes.STRING,
                     allowNull: false,
-                    primaryKey: true
-                }
+                    primaryKey: true,
+                },
             });
             this.logger.success("✅ SequelizeMeta table created.");
         }
     }
     // Fetch already applied migrations
     async getAppliedMigrations() {
-        const [results] = await this.sequelize_instance.query(`SELECT name FROM \"${constants_1.SEQUELIZE_META_TABLE_NAME}\";`);
-        return Array.isArray(results) ? results.map((r) => r.name) : [];
+        const sequelize = await this.getSequelizeInstance();
+        const queryInterface = sequelize.getQueryInterface();
+        const table_name = queryInterface.quoteTable(constants_1.SEQUELIZE_META_TABLE_NAME);
+        const column_name = queryInterface.quoteIdentifier("name");
+        const results = await sequelize.query(`SELECT ${column_name} FROM ${table_name};`, { type: sequelize_1.QueryTypes.SELECT });
+        return results.map((row) => row.name);
     }
     // Apply a single migration
     async applyMigration(file_path, operation) {
+        const sequelize = await this.getSequelizeInstance();
         const MigrationClass = require(file_path)?.default;
         if (!MigrationClass) {
             const log_msg = `Migration file has no default export: ${file_path}`;
@@ -57,20 +81,30 @@ class MigrationRunnerScript {
             throw new Error(log_msg);
         }
         const migration_instance = new MigrationClass();
-        const queryInterface = this.sequelize_instance.getQueryInterface();
-        if (operation === "up") {
-            await migration_instance.up.bind(migration_instance)(queryInterface, this.sequelize_instance);
-            await this.sequelize_instance.getQueryInterface().bulkInsert(constants_1.SEQUELIZE_META_TABLE_NAME, [{ name: path_1.default.basename(file_path) }]);
-        }
-        else {
-            await migration_instance.down.bind(migration_instance)(queryInterface, this.sequelize_instance);
-            await this.sequelize_instance.getQueryInterface().bulkDelete(constants_1.SEQUELIZE_META_TABLE_NAME, { name: path_1.default.basename(file_path) });
+        if (typeof migration_instance[operation] !== "function") {
+            const log_msg = `Migration file has no "${operation}" method: ${file_path}`;
+            this.logger.error(log_msg);
+            throw new Error(log_msg);
         }
+        const queryInterface = sequelize.getQueryInterface();
+        const migration_name = path_1.default.basename(file_path);
+        await sequelize.transaction(async (transaction) => {
+            const migration_options = { transaction };
+            if (operation === "up") {
+                await migration_instance.up.bind(migration_instance)(queryInterface, sequelize, migration_options);
+                await queryInterface.bulkInsert(constants_1.SEQUELIZE_META_TABLE_NAME, [{ name: migration_name }], migration_options);
+            }
+            else {
+                await migration_instance.down.bind(migration_instance)(queryInterface, sequelize, migration_options);
+                await queryInterface.bulkDelete(constants_1.SEQUELIZE_META_TABLE_NAME, { name: migration_name }, migration_options);
+            }
+        });
     }
     // Main runner
     async run(operation, schema_name, migration_file) {
         this.logger.info(`🏃‍♂️ Starting Migration process Operation: ${operation.toUpperCase()}, Schema: ${schema_name}, File: ${migration_file || "all"}`);
-        await this.sequelize_instance?.authenticate();
+        const sequelize = await this.getSequelizeInstance();
+        await sequelize.authenticate();
         this.logger.success("✅ Database connected.");
         await this.ensureMetaTable();
         let files = [];
@@ -84,20 +118,21 @@ class MigrationRunnerScript {
             files = [full_path];
         }
         else {
-            files = this.getMigrationFiles(schema_name).map(f => path_1.default.join(this.migrations_dir, f));
+            files = this.getMigrationFiles(schema_name).map((f) => path_1.default.join(this.migrations_dir, f));
         }
         // Sort ascending for UP, descending for DOWN
         files.sort((a, b) => {
             const getPriority = (file_path) => {
-                const file_name = file_path.split("/").pop() || "";
+                const file_name = path_1.default.basename(file_path);
                 const match = file_name.match(/^(\d+)_/);
                 return match ? Number(match[1]) : Number.MAX_SAFE_INTEGER;
             };
             const a_priority = getPriority(a);
             const b_priority = getPriority(b);
-            return operation === "up"
-                ? a_priority - b_priority
-                : b_priority - a_priority;
+            const priority_sort = a_priority - b_priority;
+            const name_sort = path_1.default.basename(a).localeCompare(path_1.default.basename(b));
+            const sort_result = priority_sort || name_sort;
+            return operation === "up" ? sort_result : -sort_result;
         });
         const applied_migrations = await this.getAppliedMigrations();
         for (const file of files) {

package/dist/database/scripts/seeder_runner_script.d.ts

@@ -4,9 +4,11 @@ declare class SeederRunnerScript {
     private readonly seeders_dir;
     private readonly db_connection;
     private readonly logger;
-    private readonly sequelize_instance;
+    private sequelize_instance?;
     constructor();
     private getSeederFiles;
+    private getSequelizeInstance;
+    private normalizeTableName;
     private ensureMetaTable;
     private getAppliedSeeders;
     private applySeeder;

package/dist/database/scripts/seeder_runner_script.js

@@ -17,20 +17,39 @@ class SeederRunnerScript {
     sequelize_instance;
     constructor() {
         main_2.InputValidatorUtil.dirExists(this.seeders_dir, true);
-        this.sequelize_instance = this.db_connection.connectSync();
     }
     // Get all seeder files
     getSeederFiles(seeder_name) {
-        let files = fs_1.default.readdirSync(this.seeders_dir).filter(f => f.endsWith(".ts"));
+        let files = fs_1.default.readdirSync(this.seeders_dir).filter((file) => {
+            if (file.endsWith(".d.ts"))
+                return false;
+            return file.endsWith(".ts") || file.endsWith(".js");
+        });
         if (seeder_name) {
-            files = files.filter(f => f.toLowerCase().includes(seeder_name.toLowerCase()));
+            files = files.filter((f) => f.toLowerCase().includes(seeder_name.toLowerCase()));
         }
         return files;
     }
+    async getSequelizeInstance() {
+        if (!this.sequelize_instance) {
+            this.sequelize_instance = await this.db_connection.connect();
+        }
+        return this.sequelize_instance;
+    }
+    normalizeTableName(table) {
+        if (typeof table === "string")
+            return table;
+        if (table && typeof table === "object") {
+            const table_obj = table;
+            return table_obj.tableName ?? table_obj.table_name ?? table_obj.name ?? "";
+        }
+        return "";
+    }
     // Ensure SequelizeSeederMeta table exists
     async ensureMetaTable() {
-        const queryInterface = this.sequelize_instance.getQueryInterface();
-        const tables = await queryInterface.showAllTables();
+        const sequelize = await this.getSequelizeInstance();
+        const queryInterface = sequelize.getQueryInterface();
+        const tables = (await queryInterface.showAllTables()).map((table) => this.normalizeTableName(table));
         if (!tables.includes(constants_1.SEQUELIZE_SEEDER_META_TABLE_NAME)) {
             this.logger.info("⏳ Creating Sequelize seeder meta table table...");
             await queryInterface.createTable(constants_1.SEQUELIZE_SEEDER_META_TABLE_NAME, {
@@ -41,31 +60,44 @@ class SeederRunnerScript {
     }
     // Get already applied seeders
     async getAppliedSeeders() {
-        const [results] = await this.sequelize_instance.query(`SELECT name FROM "${constants_1.SEQUELIZE_SEEDER_META_TABLE_NAME}";`);
-        return Array.isArray(results) ? results.map((r) => r.name) : [];
+        const sequelize = await this.getSequelizeInstance();
+        const queryInterface = sequelize.getQueryInterface();
+        const table_name = queryInterface.quoteTable(constants_1.SEQUELIZE_SEEDER_META_TABLE_NAME);
+        const column_name = queryInterface.quoteIdentifier("name");
+        const results = await sequelize.query(`SELECT ${column_name} FROM ${table_name};`, { type: sequelize_1.QueryTypes.SELECT });
+        return results.map((row) => row.name);
     }
     // Apply a single seeder
     async applySeeder(file_path, operation) {
+        const sequelize = await this.getSequelizeInstance();
         const SeederClass = require(file_path)?.default;
         if (!SeederClass) {
             throw new Error(`Seeder file has no default export: ${file_path}`);
         }
         const seeder_instance = new SeederClass();
-        const queryInterface = this.sequelize_instance.getQueryInterface();
-        if (operation === "up") {
-            await seeder_instance.up(queryInterface, this.sequelize_instance);
-            await queryInterface.bulkInsert(constants_1.SEQUELIZE_SEEDER_META_TABLE_NAME, [{ name: path_1.default.basename(file_path) }]);
-        }
-        else {
-            await seeder_instance.down(queryInterface, this.sequelize_instance);
-            await queryInterface.bulkDelete(constants_1.SEQUELIZE_SEEDER_META_TABLE_NAME, { name: path_1.default.basename(file_path) });
+        const queryInterface = sequelize.getQueryInterface();
+        const seeder_name = path_1.default.basename(file_path);
+        if (typeof seeder_instance[operation] !== "function") {
+            throw new Error(`Seeder file has no "${operation}" method: ${file_path}`);
         }
+        await sequelize.transaction(async (transaction) => {
+            const seeder_options = { transaction };
+            if (operation === "up") {
+                await seeder_instance.up(queryInterface, sequelize, seeder_options);
+                await queryInterface.bulkInsert(constants_1.SEQUELIZE_SEEDER_META_TABLE_NAME, [{ name: seeder_name }], seeder_options);
+            }
+            else {
+                await seeder_instance.down(queryInterface, sequelize, seeder_options);
+                await queryInterface.bulkDelete(constants_1.SEQUELIZE_SEEDER_META_TABLE_NAME, { name: seeder_name }, seeder_options);
+            }
+        });
     }
     // Main runner
     async run(operation, seeder_name, seeder_file) {
         try {
             this.logger.info(`🏃‍♂️ Starting seeder process Operation: ${operation.toUpperCase()}, Seeder: ${seeder_name || "all"}, File: ${seeder_file || "none"}`);
-            await this.sequelize_instance?.authenticate();
+            const sequelize = await this.getSequelizeInstance();
+            await sequelize.authenticate();
             this.logger.success("✅ Database connected.");
             await this.ensureMetaTable();
             let files = [];
@@ -78,7 +110,7 @@ class SeederRunnerScript {
                 files = [full_path];
             }
             else {
-                files = this.getSeederFiles(seeder_name).map(f => path_1.default.join(this.seeders_dir, f));
+                files = this.getSeederFiles(seeder_name).map((f) => path_1.default.join(this.seeders_dir, f));
             }
             // Sort by filename: ascending for UP, descending for DOWN
             files.sort((a, b) => (operation === "up" ? a.localeCompare(b) : b.localeCompare(a)));

package/dist/database/scripts/sequelize_model_generator_script.d.ts

@@ -1,4 +1,4 @@
-declare class SeqeulizeModelGeneratorScript {
+declare class SequelizeModelGeneratorScript {
     private name;
     private readonly schemas_dir;
     private readonly models_dir;
@@ -8,4 +8,4 @@ declare class SeqeulizeModelGeneratorScript {
     private generateModelFile;
     generateModelsFromSchemas(): void;
 }
-export default SeqeulizeModelGeneratorScript;
+export default SequelizeModelGeneratorScript;

package/dist/database/scripts/sequelize_model_generator_script.js

@@ -8,7 +8,7 @@ const path_1 = __importDefault(require("path"));
 const main_1 = require("../../utils/main");
 const constants_1 = require("../../config/constants");
 const sequelize_code_template_1 = require("../../code_templates/sequelize_code_template");
-class SeqeulizeModelGeneratorScript {
+class SequelizeModelGeneratorScript {
     name = "sequelize_model_generator_script";
     schemas_dir = constants_1.SCHEMAS_DIR;
     models_dir = constants_1.MODELS_DIR;
@@ -24,7 +24,7 @@ class SeqeulizeModelGeneratorScript {
         const imports = sorted_models
             .map((model_obj) => {
             model_names.push(model_obj.name);
-            return `import ${model_obj.name} from "./${model_obj.file_name.replace('.ts', '')}";`;
+            return `import ${model_obj.name} from "./${model_obj.file_name.replace(".ts", "")}";`;
         })
             .join("\n");
         const template = (0, sequelize_code_template_1.SEQUELIZE_MODELS_INDEX_CODE_TEMPLATE)(model_names, imports);
@@ -64,7 +64,9 @@ class SeqeulizeModelGeneratorScript {
     }
     // Loop through all schemas and generate model files
     generateModelsFromSchemas() {
-        const schema_files = fs_1.default.readdirSync(this.schemas_dir).filter(file => file.endsWith(".ts"));
+        const schema_files = fs_1.default
+            .readdirSync(this.schemas_dir)
+            .filter((file) => file.endsWith(".ts"));
         if (!schema_files.length) {
             this.logger.info("⚠️ No schema files found.");
             return;
@@ -96,7 +98,11 @@ class SeqeulizeModelGeneratorScript {
                 else if (generation_result === "created") {
                     created_count++;
                 }
-                models.push({ name: schema_content.model_name, file_name: model_file_name, migration_priority });
+                models.push({
+                    name: schema_content.model_name,
+                    file_name: model_file_name,
+                    migration_priority,
+                });
             }
             catch (error) {
                 this.logger.error(`Failed to load schema: ${schema_file_path}`, { error });
@@ -111,4 +117,4 @@ class SeqeulizeModelGeneratorScript {
         this.logger.success(`❌ Failed: ${failed_count}`);
     }
 }
-exports.default = SeqeulizeModelGeneratorScript;
+exports.default = SequelizeModelGeneratorScript;

package/dist/index.d.ts

@@ -1 +1,8 @@
 export * from "./types/main";
+export * from "./utils/main";
+export * from "./database/main";
+export * from "./middle_ware/main";
+export * from "./validators/main";
+export * from "./storage/main";
+export * from "./mailer/main";
+export * from "./rbac/main";

package/dist/index.js

@@ -15,3 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types/main"), exports);
+__exportStar(require("./utils/main"), exports);
+__exportStar(require("./database/main"), exports);
+__exportStar(require("./middle_ware/main"), exports);
+__exportStar(require("./validators/main"), exports);
+__exportStar(require("./storage/main"), exports);
+__exportStar(require("./mailer/main"), exports);
+__exportStar(require("./rbac/main"), exports);

package/dist/mailer/main.d.ts

@@ -2,4 +2,4 @@ import EmailEnqueueGenerator from "./generators/email_enqueue_generator";
 import EmailEnqueueProcessor from "./processors/email_enqueue_processor";
 import EmailDeliveryProcessor from "./processors/email_delivery_processor";
 import MailerDataLoaderUtil from "./utils/mailer_data_loader_util";
-export { EmailEnqueueGenerator, EmailEnqueueProcessor, EmailDeliveryProcessor, MailerDataLoaderUtil };
+export { EmailEnqueueGenerator, EmailEnqueueProcessor, EmailDeliveryProcessor, MailerDataLoaderUtil, };