taon 18.0.24 → 18.0.26

package/lib/context-db-migrations.js

@@ -1,605 +1,349 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextDbMigrations = void 0;
-var tslib_1 = require("tslib");
 //#region imports
-var tnp_core_1 = require("tnp-core");
-var models_1 = require("./models");
-var class_helpers_1 = require("./helpers/class-helpers");
-var taon_typeorm_1 = require("taon-typeorm");
-var ContextDbMigrations = /** @class */ (function () {
+const tnp_core_1 = require("tnp-core");
+const models_1 = require("./models");
+const class_helpers_1 = require("./helpers/class-helpers");
+const taon_typeorm_1 = require("taon-typeorm");
+class ContextDbMigrations {
+    ctx;
+    //#region fields
+    //#region fields / migration table name
+    DEFAULT_MIGRATION_TABLE_NAME = 'TAON_MIGRATION_META';
+    //#endregion
+    //#region fields / migration statuses
+    MIGRATION_STATUS_COMPLETED = 'completed';
+    MIGRATION_STATUS_PENDING = 'pending';
+    //#endregion
+    //#region fields / migration table schema
+    table = new taon_typeorm_1.Table({
+        name: this.DEFAULT_MIGRATION_TABLE_NAME,
+        columns: [
+            {
+                name: 'id',
+                type: 'integer',
+                isPrimary: true, // Mark it as the primary key
+                isGenerated: true, // Enable auto-generation
+                generationStrategy: 'increment', // Use auto-increment strategy
+            },
+            {
+                name: 'name',
+                type: 'varchar',
+                length: '255',
+                isUnique: true, // Ensure the name is unique
+                isNullable: false, // Ensure this field is required
+            },
+            {
+                // context is a part of name
+                name: 'context',
+                type: 'varchar',
+                length: '255',
+                isNullable: false, // Optional context for migrations (e.g., tenant or module name)
+            },
+            {
+                name: 'applied_at',
+                type: 'timestamp',
+                default: 'CURRENT_TIMESTAMP', // Automatically set the timestamp
+                isNullable: true,
+            },
+            {
+                name: 'status',
+                type: 'varchar',
+                length: '50',
+                default: `'${this.MIGRATION_STATUS_COMPLETED}'`,
+                isNullable: false,
+            },
+            // { // TODO not needed for now
+            //   name: 'checksum',
+            //   type: 'varchar',
+            //   length: '64',
+            //   isNullable: true, // Optional field to store a hash/checksum of migration file
+            // },
+        ],
+    });
     //#endregion
     //#endregion
     //#region constructor
-    function ContextDbMigrations(ctx) {
+    constructor(ctx) {
         this.ctx = ctx;
-        //#region fields
-        //#region fields / migration table name
-        this.DEFAULT_MIGRATION_TABLE_NAME = 'TAON_MIGRATION_META';
-        //#endregion
-        //#region fields / migration statuses
-        this.MIGRATION_STATUS_COMPLETED = 'completed';
-        this.MIGRATION_STATUS_PENDING = 'pending';
-        //#endregion
-        //#region fields / migration table schema
-        this.table = new taon_typeorm_1.Table({
-            name: this.DEFAULT_MIGRATION_TABLE_NAME,
-            columns: [
-                {
-                    name: 'id',
-                    type: 'integer',
-                    isPrimary: true, // Mark it as the primary key
-                    isGenerated: true, // Enable auto-generation
-                    generationStrategy: 'increment', // Use auto-increment strategy
-                },
-                {
-                    name: 'name',
-                    type: 'varchar',
-                    length: '255',
-                    isUnique: true, // Ensure the name is unique
-                    isNullable: false, // Ensure this field is required
-                },
-                {
-                    // context is a part of name
-                    name: 'context',
-                    type: 'varchar',
-                    length: '255',
-                    isNullable: false, // Optional context for migrations (e.g., tenant or module name)
-                },
-                {
-                    name: 'applied_at',
-                    type: 'timestamp',
-                    default: 'CURRENT_TIMESTAMP', // Automatically set the timestamp
-                    isNullable: true,
-                },
-                {
-                    name: 'status',
-                    type: 'varchar',
-                    length: '50',
-                    default: "'".concat(this.MIGRATION_STATUS_COMPLETED, "'"),
-                    isNullable: false,
-                },
-                // { // TODO not needed for now
-                //   name: 'checksum',
-                //   type: 'varchar',
-                //   length: '64',
-                //   isNullable: true, // Optional field to store a hash/checksum of migration file
-                // },
-            ],
-        });
     }
     //#endregion
     //#region methods & getters / make sure migration table exists
-    ContextDbMigrations.prototype.ensureMigrationTableExists = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var queryRunner, hasTable, error_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        //#region @websqlFunc
-                        if (this.ctx.remoteHost) {
-                            return [2 /*return*/];
-                        }
-                        queryRunner = this.ctx.connection.createQueryRunner();
-                        return [4 /*yield*/, queryRunner.connect()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, queryRunner.hasTable(this.DEFAULT_MIGRATION_TABLE_NAME)];
-                    case 3:
-                        hasTable = _a.sent();
-                        if (!hasTable) return [3 /*break*/, 6];
-                        this.ctx.logMigrations &&
-                            console.log("Table ".concat(this.DEFAULT_MIGRATION_TABLE_NAME, " already exists."));
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 4:
-                        _a.sent();
-                        return [4 /*yield*/, queryRunner.release()];
-                    case 5:
-                        _a.sent();
-                        return [2 /*return*/]; // Exit early if the table exists
-                    case 6:
-                        _a.trys.push([6, 10, 12, 14]);
-                        return [4 /*yield*/, queryRunner.createTable(this.table)];
-                    case 7:
-                        _a.sent();
-                        return [4 /*yield*/, queryRunner.createIndex(this.DEFAULT_MIGRATION_TABLE_NAME, new taon_typeorm_1.TableIndex({
-                                name: 'IDX_NAME',
-                                columnNames: ['name'],
-                            }))];
-                    case 8:
-                        _a.sent();
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 9:
-                        _a.sent();
-                        return [3 /*break*/, 14];
-                    case 10:
-                        error_1 = _a.sent();
-                        this.ctx.logMigrations &&
-                            console.error("Transaction failed [ensureMigrationTableExists]" + ", rolling back:", error_1);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 11:
-                        _a.sent();
-                        return [3 /*break*/, 14];
-                    case 12: return [4 /*yield*/, queryRunner.release()];
-                    case 13:
-                        _a.sent();
-                        return [7 /*endfinally*/];
-                    case 14: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async ensureMigrationTableExists() {
+        //#region @websqlFunc
+        if (this.ctx.remoteHost) {
+            return;
+        }
+        const queryRunner = this.ctx.connection.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        // Check if the table already exists
+        const hasTable = await queryRunner.hasTable(this.DEFAULT_MIGRATION_TABLE_NAME);
+        if (hasTable) {
+            this.ctx.logMigrations &&
+                console.log(`Table ${this.DEFAULT_MIGRATION_TABLE_NAME} already exists.`);
+            await queryRunner.commitTransaction();
+            await queryRunner.release();
+            return; // Exit early if the table exists
+        }
+        try {
+            await queryRunner.createTable(this.table);
+            await queryRunner.createIndex(this.DEFAULT_MIGRATION_TABLE_NAME, new taon_typeorm_1.TableIndex({
+                name: 'IDX_NAME',
+                columnNames: ['name'],
+            }));
+            await queryRunner.commitTransaction();
+        }
+        catch (error) {
+            this.ctx.logMigrations &&
+                console.error(`Transaction failed [ensureMigrationTableExists]` + `, rolling back:`, error);
+            await queryRunner.rollbackTransaction();
+        }
+        finally {
+            await queryRunner.release();
+        }
+        //#endregion
+    }
     //#endregion
     //#region methods & getters / revert migration to timestamp
-    ContextDbMigrations.prototype.logSelectALl = function (name, queryRunner) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, _b, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _b = (_a = console).log;
-                        _c = [name];
-                        return [4 /*yield*/, queryRunner.query("SELECT * FROM ".concat(this.DEFAULT_MIGRATION_TABLE_NAME, " WHERE context = $1"), [this.ctx.contextName])];
-                    case 1:
-                        _b.apply(_a, _c.concat([(_d.sent()).map(function (m) { return m.name; })]));
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ContextDbMigrations.prototype.revertMigrationToTimestamp = function (timestamp) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var migrationsClassFns, migrationClassesInstancesToRevert, queryRunner, appliedMigrationsForContext, appliedMigrationsForContextNames, migrationClassesInstancesToRevert_1, migrationClassesInstancesToRevert_1_1, migrationClassInstance, migrationName, e_1_1, error_2;
-            var e_1, _a;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        //#region @websqlFunc
-                        if (this.ctx.remoteHost) {
-                            return [2 /*return*/];
-                        }
-                        if (!tnp_core_1.UtilsMigrations.isValidTimestamp(timestamp)) {
-                            tnp_core_1.Helpers.throw("Invalid timestamp provided for migration revert: ".concat(timestamp));
-                        }
-                        migrationsClassFns = this.ctx
-                            .getClassFunByArr(models_1.Models.ClassType.MIGRATION)
-                            .reverse();
-                        migrationClassesInstancesToRevert = migrationsClassFns
-                            .map(function (classFn) {
-                            var timestampFromClassName = Number(tnp_core_1.UtilsMigrations.getTimestampFromClassName(class_helpers_1.ClassHelpers.getName(classFn)));
-                            if (timestampFromClassName <= timestamp) {
-                                // this.ctx.logMigrations &&
-                                //   console.log(
-                                //     `Stopping migration filter at: ${ClassHelpers.getName(classFn)} ` +
-                                //       `with timestamp ${timestampFromClassName}`,
-                                //   );
-                                return null;
-                            }
-                            return _this.ctx.getInstanceBy(classFn);
-                        })
-                            .filter(function (f) { return !!f; })
-                            .map(function (f) { return f; })
-                            .filter(function (migrationInstance) { return migrationInstance.isReadyToRun(); });
-                        queryRunner = this.ctx.connection.createQueryRunner();
-                        return [4 /*yield*/, queryRunner.connect()];
-                    case 1:
-                        _b.sent();
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 15, 17, 19]);
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 3:
-                        _b.sent();
-                        return [4 /*yield*/, queryRunner.query("SELECT name FROM ".concat(this.DEFAULT_MIGRATION_TABLE_NAME, "\n         WHERE status = $1 AND context = $2"), [this.MIGRATION_STATUS_COMPLETED, this.ctx.contextName])];
-                    case 4:
-                        appliedMigrationsForContext = _b.sent();
-                        appliedMigrationsForContextNames = appliedMigrationsForContext.map(function (m) { return m.name; });
-                        _b.label = 5;
-                    case 5:
-                        _b.trys.push([5, 11, 12, 13]);
-                        migrationClassesInstancesToRevert_1 = tslib_1.__values(migrationClassesInstancesToRevert), migrationClassesInstancesToRevert_1_1 = migrationClassesInstancesToRevert_1.next();
-                        _b.label = 6;
-                    case 6:
-                        if (!!migrationClassesInstancesToRevert_1_1.done) return [3 /*break*/, 10];
-                        migrationClassInstance = migrationClassesInstancesToRevert_1_1.value;
-                        migrationName = class_helpers_1.ClassHelpers.getName(migrationClassInstance);
-                        if (!appliedMigrationsForContextNames.includes(migrationName)) {
-                            this.ctx.logMigrations &&
-                                console.warn("Skipping migration not marked as applied: ".concat(migrationName));
-                            return [3 /*break*/, 9];
-                        }
-                        this.ctx.logMigrations &&
-                            console.log("Reverting migration: ".concat(migrationName, " , context: ").concat(this.ctx.contextName));
-                        return [4 /*yield*/, migrationClassInstance.down(queryRunner)];
-                    case 7:
-                        _b.sent();
-                        // Remove the reverted migration from the tracking table
-                        return [4 /*yield*/, queryRunner.query("DELETE FROM ".concat(this.DEFAULT_MIGRATION_TABLE_NAME, " WHERE name = $1"), [migrationName])];
-                    case 8:
-                        // Remove the reverted migration from the tracking table
-                        _b.sent();
-                        _b.label = 9;
-                    case 9:
-                        migrationClassesInstancesToRevert_1_1 = migrationClassesInstancesToRevert_1.next();
-                        return [3 /*break*/, 6];
-                    case 10: return [3 /*break*/, 13];
-                    case 11:
-                        e_1_1 = _b.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 13];
-                    case 12:
-                        try {
-                            if (migrationClassesInstancesToRevert_1_1 && !migrationClassesInstancesToRevert_1_1.done && (_a = migrationClassesInstancesToRevert_1.return)) _a.call(migrationClassesInstancesToRevert_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 13: return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 14:
-                        _b.sent();
-                        this.ctx.logMigrations &&
-                            console.log("Migrations successfully reverted " +
-                                "to the specified timestamp ".concat(timestamp, " ."));
-                        return [3 /*break*/, 19];
-                    case 15:
-                        error_2 = _b.sent();
-                        this.ctx.logMigrations &&
-                            console.error('Transaction failed, rolling back:', error_2);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 16:
-                        _b.sent();
-                        return [3 /*break*/, 19];
-                    case 17: return [4 /*yield*/, queryRunner.release()];
-                    case 18:
-                        _b.sent();
-                        return [7 /*endfinally*/];
-                    case 19: return [2 /*return*/];
+    async logSelectALl(name, queryRunner) {
+        console.log(name, (await queryRunner.query(`SELECT * FROM ${this.DEFAULT_MIGRATION_TABLE_NAME} WHERE context = $1`, [this.ctx.contextName])).map(m => m.name));
+    }
+    async revertMigrationToTimestamp(timestamp) {
+        //#region @websqlFunc
+        if (this.ctx.remoteHost) {
+            return;
+        }
+        if (!tnp_core_1.UtilsMigrations.isValidTimestamp(timestamp)) {
+            tnp_core_1.Helpers.throw(`Invalid timestamp provided for migration revert: ${timestamp}`);
+        }
+        // Get all migration class functions and reverse the order
+        const migrationsClassFns = this.ctx
+            .getClassFunByArr(models_1.Models.ClassType.MIGRATION)
+            .reverse();
+        // Filter migrations that need to be reverted
+        const migrationClassesInstancesToRevert = migrationsClassFns
+            .map(classFn => {
+            const timestampFromClassName = Number(tnp_core_1.UtilsMigrations.getTimestampFromClassName(class_helpers_1.ClassHelpers.getName(classFn)));
+            if (timestampFromClassName <= timestamp) {
+                // this.ctx.logMigrations &&
+                //   console.log(
+                //     `Stopping migration filter at: ${ClassHelpers.getName(classFn)} ` +
+                //       `with timestamp ${timestampFromClassName}`,
+                //   );
+                return null;
+            }
+            return this.ctx.getInstanceBy(classFn);
+        })
+            .filter(f => !!f)
+            .map(f => f)
+            .filter(migrationInstance => migrationInstance.isReadyToRun());
+        const queryRunner = this.ctx.connection.createQueryRunner();
+        await queryRunner.connect();
+        try {
+            await queryRunner.startTransaction();
+            // Fetch applied migrations from the database
+            const appliedMigrationsForContext = await queryRunner.query(`SELECT name FROM ${this.DEFAULT_MIGRATION_TABLE_NAME}
+         WHERE status = $1 AND context = $2`, [this.MIGRATION_STATUS_COMPLETED, this.ctx.contextName]);
+            const appliedMigrationsForContextNames = appliedMigrationsForContext.map(m => m.name);
+            // console.log({ appliedMigrationsForContextNames });
+            for (const migrationClassInstance of migrationClassesInstancesToRevert) {
+                const migrationName = class_helpers_1.ClassHelpers.getName(migrationClassInstance);
+                if (!appliedMigrationsForContextNames.includes(migrationName)) {
+                    this.ctx.logMigrations &&
+                        console.warn(`Skipping migration not marked as applied: ${migrationName}`);
+                    continue;
                 }
-            });
-        });
-    };
+                this.ctx.logMigrations &&
+                    console.log(`Reverting migration: ${migrationName} , context: ${this.ctx.contextName}`);
+                await migrationClassInstance.down(queryRunner);
+                // Remove the reverted migration from the tracking table
+                await queryRunner.query(`DELETE FROM ${this.DEFAULT_MIGRATION_TABLE_NAME} WHERE name = $1`, [migrationName]);
+            }
+            await queryRunner.commitTransaction();
+            this.ctx.logMigrations &&
+                console.log(`Migrations successfully reverted ` +
+                    `to the specified timestamp ${timestamp} .`);
+        }
+        catch (error) {
+            this.ctx.logMigrations &&
+                console.error('Transaction failed, rolling back:', error);
+            await queryRunner.rollbackTransaction();
+        }
+        finally {
+            await queryRunner.release();
+        }
+        //#endregion
+    }
     //#endregion
     //#region methods & getters / clear migration table
-    ContextDbMigrations.prototype.clearMigrationTable = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var queryRunner, error_3;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        //#region @websqlFunc
-                        if (this.ctx.remoteHost) {
-                            return [2 /*return*/];
-                        }
-                        queryRunner = this.ctx.connection.createQueryRunner();
-                        return [4 /*yield*/, queryRunner.connect()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        _a.trys.push([3, 6, 8, 10]);
-                        return [4 /*yield*/, queryRunner.clearTable(this.DEFAULT_MIGRATION_TABLE_NAME)];
-                    case 4:
-                        _a.sent();
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 5:
-                        _a.sent();
-                        return [3 /*break*/, 10];
-                    case 6:
-                        error_3 = _a.sent();
-                        this.ctx.logMigrations &&
-                            console.error('Transaction failed, rolling back:', error_3);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 7:
-                        _a.sent();
-                        return [3 /*break*/, 10];
-                    case 8: return [4 /*yield*/, queryRunner.release()];
-                    case 9:
-                        _a.sent();
-                        return [7 /*endfinally*/];
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async clearMigrationTable() {
+        //#region @websqlFunc
+        if (this.ctx.remoteHost) {
+            return;
+        }
+        const queryRunner = this.ctx.connection.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            await queryRunner.clearTable(this.DEFAULT_MIGRATION_TABLE_NAME);
+            await queryRunner.commitTransaction();
+        }
+        catch (error) {
+            this.ctx.logMigrations &&
+                console.error('Transaction failed, rolling back:', error);
+            await queryRunner.rollbackTransaction();
+        }
+        finally {
+            await queryRunner.release();
+        }
+        //#endregion
+    }
     //#endregion
     //#region methods & getters / mark all migrations as applied
-    ContextDbMigrations.prototype.markAllMigrationsAsApplied = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var migrationsClassFns, migrationClassesInstances, queryRunner, allMigrationsInDb, allMigrationInDBNames, migrationClassesInstances_1, migrationClassesInstances_1_1, instance, migrationName, e_2_1, error_4;
-            var e_2, _a;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        //#region @websqlFunc
-                        if (this.ctx.remoteHost) {
-                            return [2 /*return*/];
-                        }
-                        migrationsClassFns = this.ctx.getClassFunByArr(models_1.Models.ClassType.MIGRATION);
-                        migrationClassesInstances = migrationsClassFns
-                            .map(function (classFn) { return _this.ctx.getInstanceBy(classFn); })
-                            .map(function (f) { return f; })
-                            .filter(function (migrationInstance) { return migrationInstance.isReadyToRun(); });
-                        queryRunner = this.ctx.connection.createQueryRunner();
-                        return [4 /*yield*/, queryRunner.connect()];
-                    case 1:
-                        _b.sent();
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 15, 17, 19]);
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 3:
-                        _b.sent();
-                        return [4 /*yield*/, queryRunner.query("SELECT name FROM ".concat(this.DEFAULT_MIGRATION_TABLE_NAME))];
-                    case 4:
-                        allMigrationsInDb = _b.sent();
-                        allMigrationInDBNames = allMigrationsInDb.map(function (m) { return m.name; });
-                        _b.label = 5;
-                    case 5:
-                        _b.trys.push([5, 10, 11, 12]);
-                        migrationClassesInstances_1 = tslib_1.__values(migrationClassesInstances), migrationClassesInstances_1_1 = migrationClassesInstances_1.next();
-                        _b.label = 6;
-                    case 6:
-                        if (!!migrationClassesInstances_1_1.done) return [3 /*break*/, 9];
-                        instance = migrationClassesInstances_1_1.value;
-                        migrationName = class_helpers_1.ClassHelpers.getName(instance);
-                        if (allMigrationInDBNames.includes(migrationName)) {
-                            this.ctx.logMigrations &&
-                                console.log("Skipping already applied migration: ".concat(migrationName));
-                            return [3 /*break*/, 8];
-                        }
-                        this.ctx.logMigrations &&
-                            console.log("Marking migration as applied: ".concat(migrationName));
-                        // Insert migration as 'complete' without running
-                        return [4 /*yield*/, queryRunner.query("INSERT INTO ".concat(this.DEFAULT_MIGRATION_TABLE_NAME, " (name, status, context, applied_at) ") +
-                                "VALUES ($1, $2, $3, CURRENT_TIMESTAMP)", [
-                                migrationName,
-                                this.MIGRATION_STATUS_COMPLETED,
-                                instance.ctx.contextName,
-                            ])];
-                    case 7:
-                        // Insert migration as 'complete' without running
-                        _b.sent();
-                        _b.label = 8;
-                    case 8:
-                        migrationClassesInstances_1_1 = migrationClassesInstances_1.next();
-                        return [3 /*break*/, 6];
-                    case 9: return [3 /*break*/, 12];
-                    case 10:
-                        e_2_1 = _b.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 12];
-                    case 11:
-                        try {
-                            if (migrationClassesInstances_1_1 && !migrationClassesInstances_1_1.done && (_a = migrationClassesInstances_1.return)) _a.call(migrationClassesInstances_1);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                        return [7 /*endfinally*/];
-                    case 12: 
-                    // update all pending migrations to completed
-                    return [4 /*yield*/, queryRunner.query("UPDATE ".concat(this.DEFAULT_MIGRATION_TABLE_NAME, "\n         SET status = $1, applied_at = CURRENT_TIMESTAMP\n         WHERE status = $2"), [this.MIGRATION_STATUS_COMPLETED, this.MIGRATION_STATUS_PENDING])];
-                    case 13:
-                        // update all pending migrations to completed
-                        _b.sent();
-                        return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 14:
-                        _b.sent();
-                        this.ctx.logMigrations &&
-                            console.log('All migrations marked as applied.');
-                        return [3 /*break*/, 19];
-                    case 15:
-                        error_4 = _b.sent();
-                        this.ctx.logMigrations &&
-                            console.error('Failed to mark all migrations as applied, rolling back:', error_4);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 16:
-                        _b.sent();
-                        return [3 /*break*/, 19];
-                    case 17: return [4 /*yield*/, queryRunner.release()];
-                    case 18:
-                        _b.sent();
-                        return [7 /*endfinally*/];
-                    case 19: return [2 /*return*/];
+    async markAllMigrationsAsApplied() {
+        //#region @websqlFunc
+        if (this.ctx.remoteHost) {
+            return;
+        }
+        const migrationsClassFns = this.ctx.getClassFunByArr(models_1.Models.ClassType.MIGRATION);
+        const migrationClassesInstances = migrationsClassFns
+            .map(classFn => this.ctx.getInstanceBy(classFn))
+            .map(f => f)
+            .filter(migrationInstance => migrationInstance.isReadyToRun());
+        const queryRunner = this.ctx.connection.createQueryRunner();
+        await queryRunner.connect();
+        try {
+            await queryRunner.startTransaction();
+            // Fetch already applied migrations from the database
+            const allMigrationsInDb = await queryRunner.query(`SELECT name FROM ${this.DEFAULT_MIGRATION_TABLE_NAME}`);
+            const allMigrationInDBNames = allMigrationsInDb.map(m => m.name);
+            for (const instance of migrationClassesInstances) {
+                const migrationName = class_helpers_1.ClassHelpers.getName(instance);
+                if (allMigrationInDBNames.includes(migrationName)) {
+                    this.ctx.logMigrations &&
+                        console.log(`Skipping already applied migration: ${migrationName}`);
+                    continue;
                 }
-            });
-        });
-    };
+                this.ctx.logMigrations &&
+                    console.log(`Marking migration as applied: ${migrationName}`);
+                // Insert migration as 'complete' without running
+                await queryRunner.query(`INSERT INTO ${this.DEFAULT_MIGRATION_TABLE_NAME} (name, status, context, applied_at) ` +
+                    `VALUES ($1, $2, $3, CURRENT_TIMESTAMP)`, [
+                    migrationName,
+                    this.MIGRATION_STATUS_COMPLETED,
+                    instance.ctx.contextName,
+                ]);
+            }
+            // update all pending migrations to completed
+            await queryRunner.query(`UPDATE ${this.DEFAULT_MIGRATION_TABLE_NAME}
+         SET status = $1, applied_at = CURRENT_TIMESTAMP
+         WHERE status = $2`, [this.MIGRATION_STATUS_COMPLETED, this.MIGRATION_STATUS_PENDING]);
+            await queryRunner.commitTransaction();
+            this.ctx.logMigrations &&
+                console.log('All migrations marked as applied.');
+        }
+        catch (error) {
+            this.ctx.logMigrations &&
+                console.error('Failed to mark all migrations as applied, rolling back:', error);
+            await queryRunner.rollbackTransaction();
+        }
+        finally {
+            await queryRunner.release();
+        }
+        //#endregion
+    }
     //#endregion
     //#region methods & getters / run all migrations
-    ContextDbMigrations.prototype.runAllNotCompletedMigrations = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var migrationsClassFns, migrationClassesInstances, queryRunner, appliedMigrationsForContext, pendingMigrationsForContext, _loop_1, this_1, pendingMigrationsForContext_1, pendingMigrationsForContext_1_1, pendingContextMigration, e_3_1, _loop_2, this_2, migrationClassesInstances_2, migrationClassesInstances_2_1, instance, e_4_1, error_5;
-            var e_3, _a, e_4, _b;
-            var _this = this;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        //#region @websqlFunc
-                        if (this.ctx.remoteHost) {
-                            return [2 /*return*/];
-                        }
-                        migrationsClassFns = this.ctx.getClassFunByArr(models_1.Models.ClassType.MIGRATION);
-                        migrationClassesInstances = migrationsClassFns
-                            .map(function (classFn) { return _this.ctx.getInstanceBy(classFn); })
-                            .map(function (f) { return f; })
-                            .filter(function (migrationInstance) { return migrationInstance.isReadyToRun(); });
-                        queryRunner = this.ctx.connection.createQueryRunner();
-                        return [4 /*yield*/, queryRunner.connect()];
-                    case 1:
-                        _c.sent();
-                        _c.label = 2;
-                    case 2:
-                        _c.trys.push([2, 22, 24, 26]);
-                        return [4 /*yield*/, queryRunner.startTransaction()];
-                    case 3:
-                        _c.sent();
-                        return [4 /*yield*/, queryRunner.query("SELECT name, status FROM ".concat(this.DEFAULT_MIGRATION_TABLE_NAME, " ") +
-                                "WHERE context = $1", [this.ctx.contextName])];
-                    case 4:
-                        appliedMigrationsForContext = _c.sent();
-                        pendingMigrationsForContext = appliedMigrationsForContext.filter(function (m) { return m.status === _this.MIGRATION_STATUS_PENDING; });
-                        _loop_1 = function (pendingContextMigration) {
-                            var migrationInstance;
-                            return tslib_1.__generator(this, function (_d) {
-                                switch (_d.label) {
-                                    case 0:
-                                        migrationInstance = migrationClassesInstances.find(function (instance) {
-                                            return class_helpers_1.ClassHelpers.getName(instance) === pendingContextMigration.name;
-                                        });
-                                        if (!migrationInstance) {
-                                            this_1.ctx.logMigrations &&
-                                                console.warn("Pending migration ".concat(pendingContextMigration.name, " not found in loaded migrations."));
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                        this_1.ctx.logMigrations &&
-                                            console.log("Completing pending migration: ".concat(pendingContextMigration.name));
-                                        return [4 /*yield*/, migrationInstance.up(queryRunner)];
-                                    case 1:
-                                        _d.sent();
-                                        // Update migration status to 'complete'
-                                        return [4 /*yield*/, queryRunner.query("UPDATE ".concat(this_1.DEFAULT_MIGRATION_TABLE_NAME, "\n           SET status = $1, applied_at = CURRENT_TIMESTAMP\n           WHERE name = $2"), [this_1.MIGRATION_STATUS_COMPLETED, pendingContextMigration.name])];
-                                    case 2:
-                                        // Update migration status to 'complete'
-                                        _d.sent();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_1 = this;
-                        _c.label = 5;
-                    case 5:
-                        _c.trys.push([5, 10, 11, 12]);
-                        pendingMigrationsForContext_1 = tslib_1.__values(pendingMigrationsForContext), pendingMigrationsForContext_1_1 = pendingMigrationsForContext_1.next();
-                        _c.label = 6;
-                    case 6:
-                        if (!!pendingMigrationsForContext_1_1.done) return [3 /*break*/, 9];
-                        pendingContextMigration = pendingMigrationsForContext_1_1.value;
-                        return [5 /*yield**/, _loop_1(pendingContextMigration)];
-                    case 7:
-                        _c.sent();
-                        _c.label = 8;
-                    case 8:
-                        pendingMigrationsForContext_1_1 = pendingMigrationsForContext_1.next();
-                        return [3 /*break*/, 6];
-                    case 9: return [3 /*break*/, 12];
-                    case 10:
-                        e_3_1 = _c.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 12];
-                    case 11:
-                        try {
-                            if (pendingMigrationsForContext_1_1 && !pendingMigrationsForContext_1_1.done && (_a = pendingMigrationsForContext_1.return)) _a.call(pendingMigrationsForContext_1);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                        return [7 /*endfinally*/];
-                    case 12:
-                        _loop_2 = function (instance) {
-                            var migrationName, error_6;
-                            return tslib_1.__generator(this, function (_e) {
-                                switch (_e.label) {
-                                    case 0:
-                                        migrationName = class_helpers_1.ClassHelpers.getName(instance);
-                                        if (appliedMigrationsForContext.some(function (m) { return m.name === migrationName; })) {
-                                            this_2.ctx.logMigrations &&
-                                                console.log("Skipping already applied migration: ".concat(migrationName));
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                        this_2.ctx.logMigrations &&
-                                            console.log("Applying new migration: ".concat(migrationName));
-                                        // Insert migration as 'pending' before execution
-                                        return [4 /*yield*/, queryRunner.query("INSERT INTO ".concat(this_2.DEFAULT_MIGRATION_TABLE_NAME, " (name, status, context, applied_at) ") +
-                                                "VALUES ($1, $2, $3, NULL)", [migrationName, this_2.MIGRATION_STATUS_PENDING, this_2.ctx.contextName])];
-                                    case 1:
-                                        // Insert migration as 'pending' before execution
-                                        _e.sent();
-                                        _e.label = 2;
-                                    case 2:
-                                        _e.trys.push([2, 5, , 7]);
-                                        // Apply migration
-                                        return [4 /*yield*/, instance.up(queryRunner)];
-                                    case 3:
-                                        // Apply migration
-                                        _e.sent();
-                                        // Update migration to 'complete' after successful execution
-                                        return [4 /*yield*/, queryRunner.query("UPDATE ".concat(this_2.DEFAULT_MIGRATION_TABLE_NAME, " ") +
-                                                "SET status = '".concat(this_2.MIGRATION_STATUS_COMPLETED, "', applied_at = CURRENT_TIMESTAMP ") +
-                                                "WHERE name = $1", [migrationName])];
-                                    case 4:
-                                        // Update migration to 'complete' after successful execution
-                                        _e.sent();
-                                        return [3 /*break*/, 7];
-                                    case 5:
-                                        error_6 = _e.sent();
-                                        this_2.ctx.logMigrations &&
-                                            console.error("Failed to apply migration: ".concat(migrationName), error_6);
-                                        // Rollback pending migration entry
-                                        return [4 /*yield*/, queryRunner.query("DELETE FROM ".concat(this_2.DEFAULT_MIGRATION_TABLE_NAME, " WHERE name = $1"), [migrationName])];
-                                    case 6:
-                                        // Rollback pending migration entry
-                                        _e.sent();
-                                        throw error_6; // Rethrow to ensure the transaction is rolled back
-                                    case 7: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_2 = this;
-                        _c.label = 13;
-                    case 13:
-                        _c.trys.push([13, 18, 19, 20]);
-                        migrationClassesInstances_2 = tslib_1.__values(migrationClassesInstances), migrationClassesInstances_2_1 = migrationClassesInstances_2.next();
-                        _c.label = 14;
-                    case 14:
-                        if (!!migrationClassesInstances_2_1.done) return [3 /*break*/, 17];
-                        instance = migrationClassesInstances_2_1.value;
-                        return [5 /*yield**/, _loop_2(instance)];
-                    case 15:
-                        _c.sent();
-                        _c.label = 16;
-                    case 16:
-                        migrationClassesInstances_2_1 = migrationClassesInstances_2.next();
-                        return [3 /*break*/, 14];
-                    case 17: return [3 /*break*/, 20];
-                    case 18:
-                        e_4_1 = _c.sent();
-                        e_4 = { error: e_4_1 };
-                        return [3 /*break*/, 20];
-                    case 19:
-                        try {
-                            if (migrationClassesInstances_2_1 && !migrationClassesInstances_2_1.done && (_b = migrationClassesInstances_2.return)) _b.call(migrationClassesInstances_2);
-                        }
-                        finally { if (e_4) throw e_4.error; }
-                        return [7 /*endfinally*/];
-                    case 20: 
-                    //#endregion
-                    return [4 /*yield*/, queryRunner.commitTransaction()];
-                    case 21:
-                        //#endregion
-                        _c.sent();
-                        return [3 /*break*/, 26];
-                    case 22:
-                        error_5 = _c.sent();
-                        this.ctx.logMigrations &&
-                            console.error('Transaction failed, rolling back:', error_5);
-                        return [4 /*yield*/, queryRunner.rollbackTransaction()];
-                    case 23:
-                        _c.sent();
-                        return [3 /*break*/, 26];
-                    case 24: return [4 /*yield*/, queryRunner.release()];
-                    case 25:
-                        _c.sent();
-                        return [7 /*endfinally*/];
-                    case 26: return [2 /*return*/];
+    async runAllNotCompletedMigrations() {
+        //#region @websqlFunc
+        if (this.ctx.remoteHost) {
+            return;
+        }
+        const migrationsClassFns = this.ctx.getClassFunByArr(models_1.Models.ClassType.MIGRATION);
+        // console.log({
+        //   migrationClassesALl: migrationsClassFns.map(f => ClassHelpers.getName(f)),
+        // });
+        const migrationClassesInstances = migrationsClassFns
+            .map(classFn => this.ctx.getInstanceBy(classFn))
+            .map(f => f)
+            .filter(migrationInstance => migrationInstance.isReadyToRun());
+        // console.log({
+        //   migrationClassesInstances: migrationsClassFns.map(f =>
+        //     ClassHelpers.getName(f),
+        //   ),
+        // });
+        const queryRunner = this.ctx.connection.createQueryRunner();
+        await queryRunner.connect();
+        try {
+            await queryRunner.startTransaction();
+            // Check if the migrations table exists
+            // TODO: Implement check for migrations table existence here
+            // Fetch applied migrations from the database
+            const appliedMigrationsForContext = await queryRunner.query(`SELECT name, status FROM ${this.DEFAULT_MIGRATION_TABLE_NAME} ` +
+                `WHERE context = $1`, [this.ctx.contextName]);
+            //#region check and update pending migrations
+            const pendingMigrationsForContext = appliedMigrationsForContext.filter(m => m.status === this.MIGRATION_STATUS_PENDING);
+            // Run pending migrations first
+            for (const pendingContextMigration of pendingMigrationsForContext) {
+                const migrationInstance = migrationClassesInstances.find(instance => class_helpers_1.ClassHelpers.getName(instance) === pendingContextMigration.name);
+                if (!migrationInstance) {
+                    this.ctx.logMigrations &&
+                        console.warn(`Pending migration ${pendingContextMigration.name} not found in loaded migrations.`);
+                    continue;
                 }
-            });
-        });
-    };
-    return ContextDbMigrations;
-}());
+                this.ctx.logMigrations &&
+                    console.log(`Completing pending migration: ${pendingContextMigration.name}`);
+                await migrationInstance.up(queryRunner);
+                // Update migration status to 'complete'
+                await queryRunner.query(`UPDATE ${this.DEFAULT_MIGRATION_TABLE_NAME}
+           SET status = $1, applied_at = CURRENT_TIMESTAMP
+           WHERE name = $2`, [this.MIGRATION_STATUS_COMPLETED, pendingContextMigration.name]);
+            }
+            //#endregion
+            //#region run new migrations
+            for (const instance of migrationClassesInstances) {
+                const migrationName = class_helpers_1.ClassHelpers.getName(instance);
+                if (appliedMigrationsForContext.some(m => m.name === migrationName)) {
+                    this.ctx.logMigrations &&
+                        console.log(`Skipping already applied migration: ${migrationName}`);
+                    continue;
+                }
+                this.ctx.logMigrations &&
+                    console.log(`Applying new migration: ${migrationName}`);
+                // Insert migration as 'pending' before execution
+                await queryRunner.query(`INSERT INTO ${this.DEFAULT_MIGRATION_TABLE_NAME} (name, status, context, applied_at) ` +
+                    `VALUES ($1, $2, $3, NULL)`, [migrationName, this.MIGRATION_STATUS_PENDING, this.ctx.contextName]);
+                try {
+                    // Apply migration
+                    await instance.up(queryRunner);
+                    // Update migration to 'complete' after successful execution
+                    await queryRunner.query(`UPDATE ${this.DEFAULT_MIGRATION_TABLE_NAME} ` +
+                        `SET status = '${this.MIGRATION_STATUS_COMPLETED}', applied_at = CURRENT_TIMESTAMP ` +
+                        `WHERE name = $1`, [migrationName]);
+                }
+                catch (error) {
+                    this.ctx.logMigrations &&
+                        console.error(`Failed to apply migration: ${migrationName}`, error);
+                    // Rollback pending migration entry
+                    await queryRunner.query(`DELETE FROM ${this.DEFAULT_MIGRATION_TABLE_NAME} WHERE name = $1`, [migrationName]);
+                    throw error; // Rethrow to ensure the transaction is rolled back
+                }
+            }
+            //#endregion
+            await queryRunner.commitTransaction();
+        }
+        catch (error) {
+            this.ctx.logMigrations &&
+                console.error('Transaction failed, rolling back:', error);
+            await queryRunner.rollbackTransaction();
+        }
+        finally {
+            await queryRunner.release();
+        }
+        //#endregion
+    }
+}
 exports.ContextDbMigrations = ContextDbMigrations;
 //# sourceMappingURL=context-db-migrations.js.map