taon 21.0.51 → 21.0.53

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

@@ -0,0 +1,154 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+import { TaonBaseInjector } from "./base-injector";
+import { TaonSubscriber } from "../decorators/classes/subscriber-decorator";
+let TaonBaseSubscriberForEntity = class extends TaonBaseInjector {
+  /**
+   * Called after entity is loaded.
+   */
+  afterLoad(entity) {
+    this.ctx.logDb && console.log(`AFTER ENTITY LOADED: `, entity);
+  }
+  /**
+   * Called before query execution.
+   */
+  beforeQuery(event) {
+    this.ctx.logDb && console.log(`BEFORE QUERY: `, event.query);
+  }
+  /**
+   * Called after query execution.
+   */
+  afterQuery(event) {
+    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 = __decorateClass([
+  TaonSubscriber({
+    className: "TaonBaseSubscriberForEntity"
+  })
+], TaonBaseSubscriberForEntity);
+export {
+  TaonBaseSubscriberForEntity
+};

package/lib-prod/build-info._auto-generated_.js

@@ -0,0 +1,14 @@
+const BUILD_FRAMEWORK_CLI_NAME = "tnp";
+const APP_ID = "dev.taon.app";
+const BUILD_BASE_HREF = "";
+const PROJECT_NPM_NAME = "taon";
+const CURRENT_PACKAGE_TAON_VERSION = "v21";
+const CURRENT_PACKAGE_VERSION = "21.0.53";
+export {
+  APP_ID,
+  BUILD_BASE_HREF,
+  BUILD_FRAMEWORK_CLI_NAME,
+  CURRENT_PACKAGE_TAON_VERSION,
+  CURRENT_PACKAGE_VERSION,
+  PROJECT_NPM_NAME
+};

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

@@ -0,0 +1,28 @@
+import { TaonControllerOptions } from "./controller-options";
+class ControllerConfig extends TaonControllerOptions {
+  // ! CLONING WILL CONE DESCRIPTOR OF METHOD AND I NEED IT!
+  // public clone(override?: Partial<ControllerConfig>): ControllerConfig {
+  //   return cloneObj<ControllerConfig>(override, ControllerConfig);
+  // }
+}
+const controllerConfigFrom = (partial) => {
+  const newObj = partial || {};
+  newObj.methods = newObj.methods || {};
+  for (const methodName in newObj.methods) {
+    if (newObj.methods.hasOwnProperty(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] || {};
+        }
+      }
+    }
+  }
+  return newObj;
+};
+export {
+  ControllerConfig,
+  controllerConfigFrom
+};

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

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

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

@@ -0,0 +1,9 @@
+class MethodConfig {
+  // ! CLONING WILL CONE DESCRIPTOR OF METHOD AND I NEED IT!
+  // public clone(override?: Partial<MethodConfig>): MethodConfig {
+  //   return cloneObj<MethodConfig>(override, MethodConfig);
+  // }
+}
+export {
+  MethodConfig
+};

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

@@ -0,0 +1,9 @@
+class ParamConfig {
+  // ! CLONING WILL CONE DESCRIPTOR OF METHOD AND I NEED IT!
+  // public clone(override?: Partial<ParamConfig>): ParamConfig {
+  //   return cloneObj<ParamConfig>(override, ParamConfig);
+  // }
+}
+export {
+  ParamConfig
+};

package/lib-prod/constants.js

@@ -0,0 +1,29 @@
+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;
+const apiPrefix = "api";
+export {
+  CURRENT_HOST_BACKEND_PORT,
+  CURRENT_HOST_URL,
+  TAON_CONTEXT,
+  TaonEntityKeysToOmitArr,
+  apiPrefix
+};

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

@@ -0,0 +1,339 @@
+import { Helpers__NS__throwError, UtilsMigrations__NS__getTimestampFromClassName, UtilsMigrations__NS__isValidTimestamp } from "tnp-core/lib-prod";
+import { Models__NS__ClassType } from "./models";
+import { ClassHelpers__NS__getName } from "./helpers/class-helpers";
+import {
+  Table,
+  TableIndex
+} from "taon-typeorm/lib-prod";
+class ContextDbMigrations {
+  //#endregion
+  //#endregion
+  //#region constructor
+  constructor(ctx) {
+    this.ctx = 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 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() {
+    if (this.ctx.isRemoteHost || !this.ctx.connection) {
+      return;
+    }
+    const queryRunner = this.ctx.connection.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    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;
+    }
+    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
+  //#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) {
+    if (this.ctx.isRemoteHost || !this.ctx.connection) {
+      return;
+    }
+    if (!UtilsMigrations__NS__isValidTimestamp(timestamp)) {
+      Helpers__NS__throwError(
+        `Invalid timestamp provided for migration revert: ${timestamp}`
+      );
+    }
+    const migrationsClassFns = this.ctx.getClassFunByArr(Models__NS__ClassType.MIGRATION).reverse();
+    const migrationClassesInstancesToRevert = migrationsClassFns.map((classFn) => {
+      const timestampFromClassName = Number(
+        UtilsMigrations__NS__getTimestampFromClassName(
+          ClassHelpers__NS__getName(classFn)
+        )
+      );
+      if (timestampFromClassName <= timestamp) {
+        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();
+      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
+      );
+      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);
+        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
+  //#region methods & getters / clear migration table
+  async clearMigrationTable() {
+    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
+  //#region methods & getters / mark all migrations as applied
+  async markAllMigrationsAsApplied() {
+    if (this.ctx.isRemoteHost || !this.ctx.connection) {
+      return;
+    }
+    const migrationsClassFns = this.ctx.getClassFunByArr(
+      Models__NS__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();
+      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}`);
+        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
+          ]
+        );
+      }
+      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
+  //#region methods & getters / run all migrations
+  async runAllNotCompletedMigrations() {
+    if (this.ctx.isRemoteHost || !this.ctx.connection) {
+      return;
+    }
+    const migrationsClassFns = this.ctx.getClassFunByArr(
+      Models__NS__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();
+      const appliedMigrationsForContext = await queryRunner.query(
+        `SELECT name, status FROM ${this.DEFAULT_MIGRATION_TABLE_NAME} WHERE context = $1`,
+        [this.ctx.contextName]
+      );
+      const pendingMigrationsForContext = appliedMigrationsForContext.filter(
+        (m) => m.status === this.MIGRATION_STATUS_PENDING
+      );
+      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);
+        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]
+        );
+      }
+      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}`);
+        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 {
+          await instance.up(queryRunner);
+          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);
+          await queryRunner.query(
+            `DELETE FROM ${this.DEFAULT_MIGRATION_TABLE_NAME} WHERE name = $1`,
+            [migrationName]
+          );
+          throw error;
+        }
+      }
+      await queryRunner.commitTransaction();
+    } catch (error) {
+      this.ctx.logMigrations && console.error("Transaction failed, rolling back:", error);
+      await queryRunner.rollbackTransaction();
+    } finally {
+      await queryRunner.release();
+    }
+  }
+  //#endregion
+}
+export {
+  ContextDbMigrations
+};