taon 21.0.52 → 21.0.54

package/lib-prod/base-classes/base-subscriber-for-entity.js

@@ -0,0 +1,145 @@
+import { TaonBaseInjector } from './base-injector';
+import { TaonSubscriber } from '../decorators/classes/subscriber-decorator';
+let TaonBaseSubscriberForEntity = class TaonBaseSubscriberForEntity extends TaonBaseInjector {
+    /**
+     * Called after entity is loaded.
+     */
+    afterLoad(entity) {
+        this.ctx.logDb &&
+            console.log(`AFTER ENTITY LOADED: `, entity);
+    }
+    /**
+     * Called before query execution.
+     */
+    beforeQuery(event) {
+        // BeforeQueryEvent<any>
+        this.ctx.logDb &&
+            console.log(`BEFORE QUERY: `, event.query);
+    }
+    /**
+     * Called after query execution.
+     */
+    afterQuery(event) {
+        // AfterQueryEvent<any>
+        this.ctx.logDb &&
+            console.log(`AFTER QUERY: `, event.query);
+    }
+    /**
+     * Called before entity insertion.
+     */
+    beforeInsert(event) {
+        this.ctx.logDb &&
+            console.log(`BEFORE ENTITY INSERTED: `, event.entity);
+    }
+    /**
+     * Called after entity insertion.
+     */
+    afterInsert(event) {
+        this.ctx.logDb &&
+            console.log(`AFTER ENTITY INSERTED: `, event.entity);
+    }
+    /**
+     * Called before entity update.
+     */
+    beforeUpdate(event) {
+        this.ctx.logDb &&
+            console.log(`BEFORE ENTITY UPDATED: `, event.entity);
+    }
+    /**
+     * Called after entity update.
+     */
+    afterUpdate(event) {
+        this.ctx.logDb &&
+            console.log(`AFTER ENTITY UPDATED: `, event.entity);
+    }
+    /**
+     * Called before entity removal.
+     */
+    beforeRemove(event) {
+        this.ctx.logDb &&
+            console.log(`BEFORE ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+    }
+    /**
+     * Called after entity removal.
+     */
+    afterRemove(event) {
+        this.ctx.logDb &&
+            console.log(`AFTER ENTITY WITH ID ${event.entityId} REMOVED: `, event.entity);
+    }
+    /**
+     * Called before entity removal.
+     */
+    beforeSoftRemove(event) {
+        this.ctx.logDb &&
+            console.log(`BEFORE ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
+    }
+    /**
+     * Called after entity removal.
+     */
+    afterSoftRemove(event) {
+        this.ctx.logDb &&
+            console.log(`AFTER ENTITY WITH ID ${event.entityId} SOFT REMOVED: `, event.entity);
+    }
+    /**
+     * Called before entity recovery.
+     */
+    beforeRecover(event) {
+        this.ctx.logDb &&
+            console.log(`BEFORE ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
+    }
+    /**
+     * Called after entity recovery.
+     */
+    afterRecover(event) {
+        this.ctx.logDb &&
+            console.log(`AFTER ENTITY WITH ID ${event.entityId} RECOVERED: `, event.entity);
+    }
+    /**
+     * Called before transaction start.
+     */
+    beforeTransactionStart(event) {
+        this.ctx.logDb &&
+            console.log(`BEFORE TRANSACTION STARTED: `, event);
+    }
+    /**
+     * Called after transaction start.
+     */
+    afterTransactionStart(event) {
+        this.ctx.logDb &&
+            console.log(`AFTER TRANSACTION STARTED: `, event);
+    }
+    /**
+     * Called before transaction commit.
+     */
+    beforeTransactionCommit(event) {
+        this.ctx.logDb &&
+            console.log(`BEFORE TRANSACTION COMMITTED: `, event);
+    }
+    /**
+     * Called after transaction commit.
+     */
+    afterTransactionCommit(event) {
+        this.ctx.logDb &&
+            console.log(`AFTER TRANSACTION COMMITTED: `, event);
+    }
+    /**
+     * Called before transaction rollback.
+     */
+    beforeTransactionRollback(event) {
+        this.ctx.logDb &&
+            console.log(`BEFORE TRANSACTION ROLLBACK: `, event);
+    }
+    /**
+     * Called after transaction rollback.
+     */
+    afterTransactionRollback(event) {
+        this.ctx.logDb &&
+            console.log(`AFTER TRANSACTION ROLLBACK: `, event);
+    }
+};
+TaonBaseSubscriberForEntity = __decorate([
+    TaonSubscriber({
+        className: 'TaonBaseSubscriberForEntity',
+    })
+], TaonBaseSubscriberForEntity);
+export { TaonBaseSubscriberForEntity };

package/lib-prod/base-classes/{base.ts → base.js}

@@ -1,17 +1,4 @@
-import * as abstractEntity from './base-abstract-entity';
-import * as baseService from './base-angular-service';
-import * as baseClass from './base-class';
-import * as baseContext from './base-context';
-import * as controller from './base-controller';
-import * as crudController from './base-crud-controller';
-import * as customRepository from './base-custom-repository';
-import * as entity from './base-entity';
-import * as baseMiddleware from './base-middleware';
-import * as baseMigration from './base-migration';
-import * as provider from './base-provider';
-import * as repository from './base-repository';
-import * as baseSubscriberEntity from './base-subscriber-for-entity';
-
+export {};
 // TODO new 5.8 typescript is not allowing this
 // export namespace Base {
 //   export import Controller = controller.TaonBaseController;
@@ -28,4 +15,4 @@ import * as baseSubscriberEntity from './base-subscriber-for-entity';
 //   export import Middleware = baseMiddleware.TaonBaseMiddleware;
 //   export import AngularService = baseService.TaonBaseAngularService;
 //   export const Context = baseContext.TaonBaseContext;
-// }
+// }

package/lib-prod/{build-info._auto-generated_.ts → build-info._auto-generated_.js}

@@ -22,6 +22,5 @@ export const CURRENT_PACKAGE_TAON_VERSION = 'v21';
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export const CURRENT_PACKAGE_VERSION = '21.0.52';
+export const CURRENT_PACKAGE_VERSION = '21.0.54';
 // THIS FILE IS GENERATED - DO NOT MODIFY
-      

package/lib-prod/config/controller-config.js

@@ -0,0 +1,28 @@
+// import { cloneObj } from '../helpers/clone-obj';
+import { TaonControllerOptions } from './controller-options';
+// import { ParamConfig } from './param-config';
+export class ControllerConfig extends TaonControllerOptions {
+}
+export const controllerConfigFrom = (partial) => {
+    const newObj = partial || {};
+    newObj.methods = newObj.methods || {};
+    for (const methodName in newObj.methods) {
+        if (newObj.methods.hasOwnProperty(methodName)) {
+            // newObj.methods[methodName] = new MethodConfig().clone(
+            //   newObj.methods[methodName],
+            // );
+            newObj.methods[methodName] = newObj.methods[methodName] || {};
+            const params = newObj.methods[methodName].parameters || {};
+            newObj.methods[methodName].parameters = params
+                ? params
+                : {};
+            for (const paramName in params) {
+                if (params.hasOwnProperty(paramName)) {
+                    params[paramName] = params[paramName] || {};
+                    // params[paramName] = new ParamConfig().clone(params[paramName]);
+                }
+            }
+        }
+    }
+    return newObj;
+};

package/lib-prod/config/controller-options.js

@@ -0,0 +1,3 @@
+import { DecoratorAbstractOpt } from '../decorators/decorator-abstract-opt';
+export class TaonControllerOptions extends DecoratorAbstractOpt {
+}

package/lib-prod/config/method-config.js

@@ -0,0 +1,7 @@
+//#region models / method config
+/**
+ * @link './decorators/http/http-methods-decorators.ts' TaonHttpDecoratorOptions
+ */
+export class MethodConfig {
+}
+//#endregion

package/lib-prod/config/param-config.js

@@ -0,0 +1,3 @@
+// import { cloneObj } from '../helpers/clone-obj';
+export class ParamConfig {
+}

package/lib-prod/constants.js

@@ -0,0 +1,33 @@
+export const TaonEntityKeysToOmitArr = [
+    'ctrl',
+    'clone',
+    '__endpoint_context__',
+    'ctx',
+    'inject',
+    '_',
+    'relation',
+    'relations',
+    'inject',
+    'injectRepo',
+    'injectCustomRepository',
+    'injectCustomRepo',
+    'injectController',
+    'injectCtrl',
+    'injectProvider',
+    'injectMiddleware',
+];
+let TAON_CONTEXT;
+/* */
+/* */
+let CURRENT_HOST_BACKEND_PORT;
+/* */
+/* */
+/* */
+/* */
+let CURRENT_HOST_URL;
+/* */
+/* */
+/* */
+/* */
+export { TAON_CONTEXT, CURRENT_HOST_BACKEND_PORT, CURRENT_HOST_URL };
+export const apiPrefix = 'api';

package/lib-prod/context-db-migrations.js

@@ -0,0 +1,342 @@
+//#region imports
+import { Helpers__NS__throwError, UtilsMigrations__NS__getTimestampFromClassName, UtilsMigrations__NS__isValidTimestamp } from 'tnp-core/lib-prod';
+import { ClassHelpers__NS__getName } from './helpers/class-helpers';
+import { Table, TableIndex, } from 'taon-typeorm/lib-prod';
+export class ContextDbMigrations {
+    //#endregion
+    //#endregion
+    //#region constructor
+    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 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
+    //#region methods & getters / make sure migration table exists
+    async ensureMigrationTableExists() {
+        //#region @websqlFunc
+        if (this.ctx.isRemoteHost || !this.ctx.connection) {
+            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 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
+    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.isRemoteHost || !this.ctx.connection) {
+            return;
+        }
+        if (!UtilsMigrations__NS__isValidTimestamp(timestamp)) {
+            Helpers__NS__throwError(`Invalid timestamp provided for migration revert: ${timestamp}`);
+        }
+        // Get all migration class functions and reverse the order
+        const migrationsClassFns = this.ctx
+            .getClassFunByArr(Models.ClassType.MIGRATION)
+            .reverse();
+        // Filter migrations that need to be reverted
+        const migrationClassesInstancesToRevert = migrationsClassFns
+            .map(classFn => {
+            const timestampFromClassName = Number(UtilsMigrations__NS__getTimestampFromClassName(ClassHelpers__NS__getName(classFn)));
+            if (timestampFromClassName <= timestamp) {
+                // this.ctx.logMigrations &&
+                //   console.log(
+                //     `Stopping migration filter at: ${ClassHelpers__NS__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 = ClassHelpers__NS__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
+    async clearMigrationTable() {
+        //#region @websqlFunc
+        if (this.ctx.isRemoteHost || !this.ctx.connection) {
+            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
+    async markAllMigrationsAsApplied() {
+        //#region @websqlFunc
+        if (this.ctx.isRemoteHost || !this.ctx.connection) {
+            return;
+        }
+        const migrationsClassFns = this.ctx.getClassFunByArr(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 = ClassHelpers__NS__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
+    async runAllNotCompletedMigrations() {
+        //#region @websqlFunc
+        if (this.ctx.isRemoteHost || !this.ctx.connection) {
+            return;
+        }
+        const migrationsClassFns = this.ctx.getClassFunByArr(Models.ClassType.MIGRATION);
+        // console.log({
+        //   migrationClassesALl: migrationsClassFns.map(f => ClassHelpers__NS__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__NS__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 => ClassHelpers__NS__getName(instance) === pendingContextMigration.name);
+                if (!migrationInstance) {
+                    this.ctx.logMigrations &&
+                        console.warn(`Pending migration ${pendingContextMigration.name} not found in loaded migrations.`);
+                    continue;
+                }
+                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 = ClassHelpers__NS__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
+    }
+}