taon 21.0.52 → 21.0.53

package/lib-prod/models.js

@@ -0,0 +1,109 @@
+import { RestResponseWrapper } from "ng2-rest/lib-prod";
+import { ___NS__cloneDeep, ___NS__merge } from "tnp-core/lib-prod";
+class TaonRestResponseWrapper extends RestResponseWrapper {
+}
+const BaseTaonClassesNames = [
+  "BaseCrudController",
+  "BaseController",
+  "BaseAbstractEntity",
+  "BaseEntity",
+  "BaseContext",
+  "BaseCustomRepository",
+  "BaseFileUploadMiddleware",
+  "BaseMiddleware",
+  "BaseClass",
+  "BaseInjector",
+  "BaseMigration",
+  "BaseProvider",
+  "BaseRepository",
+  "BaseSubscriberForEntity",
+  "BaseCliWorkerController",
+  "PortsController",
+  "PortsContext"
+];
+const TaonTempDatabasesFolder = "databases";
+const TaonTempRoutesFolder = "routes";
+const Models__NS__DatabasesFolder = TaonTempDatabasesFolder;
+var Models__NS__ClassType = /* @__PURE__ */ ((Models__NS__ClassType2) => {
+  Models__NS__ClassType2["ENTITY"] = "ENTITY";
+  Models__NS__ClassType2["CONTROLLER"] = "CONTROLLER";
+  Models__NS__ClassType2["REPOSITORY"] = "REPOSITORY";
+  Models__NS__ClassType2["PROVIDER"] = "PROVIDER";
+  Models__NS__ClassType2["SUBSCRIBER"] = "SUBSCRIBER";
+  Models__NS__ClassType2["MIGRATION"] = "MIGRATION";
+  Models__NS__ClassType2["MIDDLEWARE"] = "MIDDLEWARE";
+  return Models__NS__ClassType2;
+})(Models__NS__ClassType || {});
+const Models__NS__ClassTypeKey = {
+  ["ENTITY" /* ENTITY */]: "entities",
+  ["CONTROLLER" /* CONTROLLER */]: "controllers",
+  ["REPOSITORY" /* REPOSITORY */]: "repositories",
+  ["PROVIDER" /* PROVIDER */]: "providers",
+  ["SUBSCRIBER" /* SUBSCRIBER */]: "subscribers",
+  ["MIGRATION" /* MIGRATION */]: "migrations",
+  ["MIDDLEWARE" /* MIDDLEWARE */]: "middlewares"
+};
+class Models__NS__DatabaseConfigTypeOrm {
+  /**
+   * database name
+   */
+  database;
+  /**
+   * only for file base db: sqlite, sqljs
+   */
+  location;
+  synchronize;
+  dropSchema;
+  type;
+  /**
+   * Persists db on disk/local-storage if serverless db
+   */
+  autoSave;
+  /**
+   * for websql db mode
+   * true by default
+   */
+  useLocalForage;
+  logging;
+  databasePort;
+  databaseHost;
+  databaseUsername;
+  databasePassword;
+}
+class Models__NS__DatabaseConfig extends Models__NS__DatabaseConfigTypeOrm {
+  /**
+   * Default value 'DROP_ALL'.
+   *
+   * Tell framework what is happening with db
+   * when context is starting.
+   */
+  recreateMode;
+  static from(databasePartialConfig) {
+    return ___NS__merge(new Models__NS__DatabaseConfig(), databasePartialConfig);
+  }
+  get databaseConfigTypeORM() {
+    const result = ___NS__cloneDeep(this);
+    if (result.recreateMode) {
+      if (result.recreateMode === "DROP_DB+MIGRATIONS") {
+        result.synchronize = true;
+        result.dropSchema = true;
+      } else if (result.recreateMode === "PRESERVE_DATA+MIGRATIONS") {
+        result.synchronize = false;
+        result.dropSchema = false;
+      }
+    }
+    delete result.recreateMode;
+    return result;
+  }
+}
+export {
+  BaseTaonClassesNames,
+  Models__NS__ClassType,
+  Models__NS__ClassTypeKey,
+  Models__NS__DatabaseConfig,
+  Models__NS__DatabaseConfigTypeOrm,
+  Models__NS__DatabasesFolder,
+  TaonRestResponseWrapper,
+  TaonTempDatabasesFolder,
+  TaonTempRoutesFolder
+};

package/lib-prod/orm/columns.js

@@ -0,0 +1,124 @@
+import { Column } from "taon-typeorm/lib-prod";
+import { ___NS__isNil } from "tnp-core/lib-prod";
+import {
+  Repository,
+  Connection,
+  Generated as Generated2,
+  AfterInsert,
+  AfterLoad,
+  AfterRecover,
+  AfterRemove,
+  AfterSoftRemove,
+  AfterUpdate,
+  BeforeInsert,
+  BeforeRecover,
+  BeforeRemove,
+  BeforeSoftRemove,
+  BeforeUpdate,
+  TreeChildren,
+  TreeParent,
+  PrimaryGeneratedColumn,
+  PrimaryColumn,
+  Index,
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Column as Column2,
+  VersionColumn,
+  VirtualColumn,
+  JoinTable,
+  JoinColumn,
+  OneToMany,
+  OneToOne,
+  ManyToMany,
+  ManyToOne
+} from "taon-typeorm/lib-prod";
+import { Column as Column3 } from "taon-typeorm/lib-prod";
+import { Generated as Generated3 } from "taon-typeorm/lib-prod";
+const StringColumn = (defaultValue = null, length = 100) => Column({
+  type: "varchar",
+  length,
+  nullable: ___NS__isNil(defaultValue),
+  default: defaultValue
+});
+const String100Column = (defaultValue = null) => Column({
+  type: "varchar",
+  length: 100,
+  nullable: ___NS__isNil(defaultValue),
+  default: defaultValue
+});
+const String20Column = (defaultValue = null) => Column({
+  type: "varchar",
+  length: 20,
+  nullable: ___NS__isNil(defaultValue),
+  default: defaultValue
+});
+const String45Column = (defaultValue = null) => Column({
+  type: "varchar",
+  length: 45,
+  nullable: ___NS__isNil(defaultValue),
+  default: defaultValue
+});
+const String500Column = (defaultValue = null) => Column({
+  type: "varchar",
+  length: 500,
+  nullable: ___NS__isNil(defaultValue),
+  default: defaultValue
+});
+const String200Column = (defaultValue = null) => Column({
+  type: "varchar",
+  length: 200,
+  nullable: ___NS__isNil(defaultValue),
+  default: defaultValue
+});
+const NumberColumn = () => Column({ type: "int", nullable: true });
+const DecimalNumberColumn = () => Column({ type: "float", nullable: true });
+const SimpleJsonColumn = () => Column({ type: "simple-json", nullable: true });
+const BooleanColumn = (defaultValue) => Column({ type: "boolean", nullable: true, default: defaultValue });
+const DateTimeColumn = (defaultValue = null) => Column({ type: "datetime", nullable: true, default: defaultValue });
+export {
+  AfterInsert,
+  AfterLoad,
+  AfterRecover,
+  AfterRemove,
+  AfterSoftRemove,
+  AfterUpdate,
+  BeforeInsert,
+  BeforeRecover,
+  BeforeRemove,
+  BeforeSoftRemove,
+  BeforeUpdate,
+  BooleanColumn,
+  Column2 as Column,
+  Connection,
+  CreateDateColumn,
+  Column3 as CustomColumn,
+  DateTimeColumn,
+  DecimalNumberColumn,
+  DeleteDateColumn,
+  Generated2 as Generated,
+  Generated3 as GeneratedColumn,
+  Index,
+  JoinColumn,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+  NumberColumn,
+  OneToMany,
+  OneToOne,
+  PrimaryColumn,
+  PrimaryGeneratedColumn,
+  Repository,
+  SimpleJsonColumn,
+  String100Column,
+  String200Column,
+  String20Column,
+  String45Column,
+  String500Column,
+  StringColumn,
+  TreeChildren,
+  TreeParent,
+  UpdateDateColumn,
+  VersionColumn,
+  VirtualColumn
+};

package/lib-prod/orm/index.js

@@ -0,0 +1 @@
+export * from "./columns";

package/lib-prod/package.json

@@ -1,4 +1,4 @@
 {
   "name": "taon/lib-prod",
-  "version": "21.0.52"
+  "version": "21.0.53"
 }

package/lib-prod/realtime/realtime-client.js

@@ -0,0 +1,196 @@
+import { Observable } from "rxjs";
+import { ___NS__isObject, ___NS__isString } from "tnp-core/lib-prod";
+import { Helpers__NS__logInfo } from "tnp-core/lib-prod";
+import { ClassHelpers__NS__getClassFnFromObject, ClassHelpers__NS__getName, ClassHelpers__NS__getUniqueKey } from "../helpers/class-helpers";
+import { Symbols__NS__REALTIME } from "../symbols";
+import { RealtimeSubsManager } from "./realtime-subs-manager";
+class RealtimeClient {
+  constructor(core) {
+    this.core = core;
+    this.core = core;
+    if (!core.ctx.disabledRealtime) {
+      this.init();
+    }
+  }
+  subsManagers = {};
+  //#region methods & getters / init
+  init() {
+    const nspPath = {
+      global: this.core.pathFor(),
+      realtime: this.core.pathFor(
+        Symbols__NS__REALTIME.NAMESPACE(this.core.ctx.contextName)
+      )
+    };
+    if (this.core.ctx.config.frontendHost && this.core.ctx.config.frontendHost !== "" && this.core.ctx.isRunningInsideDocker) {
+      this.core.ctx.logRealtime && Helpers__NS__logInfo(
+        `[${this.core.ctx.contextName}] USING FRONTEND HOST ${this.core.ctx.config.frontendHost} FOR REALTIME`
+      );
+      nspPath.global = new URL(
+        `${this.core.ctx.frontendHostUri.origin}${nspPath.global.pathname}`
+      );
+      nspPath.realtime = new URL(
+        `${this.core.ctx.frontendHostUri.origin}${nspPath.realtime.pathname}`
+      );
+    } else {
+      this.core.ctx.logRealtime && Helpers__NS__logInfo(
+        `[${this.core.ctx.contextName}] Not using frontend host for realtime`
+      );
+    }
+    this.core.ctx.logRealtime && console.info(
+      "[CLIENT] NAMESPACE GLOBAL ",
+      nspPath.global.href + ` host: ${this.core.ctx.host}`
+    );
+    this.core.ctx.logRealtime && console.info(
+      "[CLIENT] NAMESPACE REALTIME",
+      nspPath.realtime.href + ` host: ${this.core.ctx.host}`
+    );
+    this.core.conectSocketFE = this.core.strategy.ioClient(
+      nspPath.global.origin,
+      {
+        path: nspPath.global.pathname
+      }
+    );
+    if (this.core.conectSocketFE.on) {
+      this.core.conectSocketFE.on("connect", () => {
+        this.core.ctx.logRealtime && console.info(
+          `[CLIENT] connected to GLOBAL namespace ${nspPath.global.pathname} of host: ${this.core.ctx.host}`
+        );
+      });
+    }
+    this.core.socketFE = this.core.strategy.ioClient(nspPath.realtime.origin, {
+      path: nspPath.realtime.pathname
+    });
+    if (this.core.socketFE.on) {
+      this.core.socketFE.on("connect", () => {
+        this.core.ctx.logRealtime && console.info(
+          `[CLIENT] connected to REALTIME namespace ${nspPath.realtime.pathname} host: ${this.core.ctx.host}`
+        );
+      });
+    }
+  }
+  //#endregion
+  //#region methods & getters  / listen changes entity
+  /**
+   * Usage:
+   * myContext.realtimeClient.listenChangesEntity(myEntityInstance);
+   *
+   *
+   * Changes trigger on backend needs to be done manually.. example code:
+   *
+   * myContext.realtimeServer.triggerEntityChanges(myEntityInstance);
+   * ...
+   */
+  listenChangesEntity(entityClassFnOrObj, options) {
+    options = options || {};
+    if (___NS__isObject(entityClassFnOrObj)) {
+      const orgObj = entityClassFnOrObj;
+      entityClassFnOrObj = ClassHelpers__NS__getClassFnFromObject(entityClassFnOrObj);
+      const uniqueKey = ClassHelpers__NS__getUniqueKey(entityClassFnOrObj);
+      if (uniqueKey) {
+        options.idOrUniqValue = orgObj[uniqueKey];
+      }
+    }
+    const { property, customEvent } = options;
+    const className = !customEvent && ClassHelpers__NS__getName(entityClassFnOrObj);
+    if (___NS__isString(property)) {
+      if (property.trim() === "") {
+        throw new Error(
+          `[Taon][listenChangesEntity.. incorrect property '' for ${className}`
+        );
+      }
+    }
+    return new Observable((observer) => {
+      if (this.core.ctx.disabledRealtime) {
+        console.error(`[Taon][realtime rxjs] remove taon config flag:
+
+        ...
+        disabledRealtime: true
+        ...
+
+to use socket realtime connection;
+        `);
+        return () => {
+        };
+      }
+      let roomName;
+      if (customEvent) {
+        roomName = Symbols__NS__REALTIME.ROOM_NAME_CUSTOM(
+          this.core.ctx.contextName,
+          customEvent
+        );
+      } else {
+        roomName = ___NS__isString(property) ? Symbols__NS__REALTIME.ROOM_NAME_UPDATE_ENTITY_PROPERTY(
+          this.core.ctx.contextName,
+          className,
+          property,
+          options.idOrUniqValue
+        ) : Symbols__NS__REALTIME.ROOM_NAME_UPDATE_ENTITY(
+          this.core.ctx.contextName,
+          className,
+          options.idOrUniqValue
+        );
+      }
+      const roomSubOptions = {
+        core: this.core,
+        property,
+        roomName,
+        customEvent
+      };
+      const subManagerId = this.getUniqueIdentifierForConnection(roomSubOptions);
+      if (!this.subsManagers[subManagerId]) {
+        this.subsManagers[subManagerId] = new RealtimeSubsManager(
+          roomSubOptions
+        );
+      }
+      const inst = this.subsManagers[subManagerId];
+      inst.add(observer);
+      inst.startListenIfNotStarted(this.core.socketFE);
+      return () => {
+        inst.remove(observer);
+      };
+    });
+  }
+  //#endregion
+  //#region listen changes entity table
+  /**
+   * Listen changes entity table
+   * Example: for pagination, lists update ...
+   */
+  listenChangesEntityTable(entityClassFn) {
+    const className = ClassHelpers__NS__getName(entityClassFn);
+    return this.listenChangesEntity(entityClassFn, {
+      customEvent: Symbols__NS__REALTIME.TABLE_CHANGE(
+        this.core.ctx.contextName,
+        className
+      )
+    });
+  }
+  //#endregion
+  //#region listen changes custom event
+  listenChangesCustomEvent(customEvent) {
+    return this.listenChangesEntity(void 0, {
+      customEvent
+    });
+  }
+  //#endregion
+  //#region methods & getters / trigger custom event\
+  /**
+   * Trigger custom event on backend
+   * @param customEvent global event name
+   * @param dataToPush
+   */
+  triggerCustomEvent(customEvent, dataToPush) {
+    this.core.socketFE.emit(customEvent, dataToPush);
+  }
+  //#endregion
+  //#region methods & getters / get room id from
+  getUniqueIdentifierForConnection(options) {
+    let url = new URL(options.core.ctx.host);
+    let contextNameForCommunication = options.core.ctx.contextNameForCommunication;
+    return `${contextNameForCommunication}:${url.origin}|${options.roomName}|${options.property}|${options.customEvent}`;
+  }
+  //#endregion
+}
+export {
+  RealtimeClient
+};

package/lib-prod/realtime/realtime-core.js

@@ -0,0 +1,82 @@
+import { UtilsOs__NS__isElectron, UtilsOs__NS__isWebSQL } from "tnp-core/lib-prod";
+import { apiPrefix } from "../constants";
+import { RealtimeClient } from "./realtime-client";
+import { RealtimeServer } from "./realtime-server";
+import {
+  RealtimeStrategyIpc,
+  RealtimeStrategyMock,
+  RealtimeStrategySocketIO
+} from "./realtime-strategy";
+class RealtimeCore {
+  //#endregion
+  //#region constructor
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.ctx = ctx;
+    this.strategy = this.resolveStrategy();
+    if (UtilsOs__NS__isWebSQL) {
+      this.server = new RealtimeServer(this);
+      this.client = new RealtimeClient(this);
+    } else {
+      this.client = new RealtimeClient(this);
+      this.server = new RealtimeServer(this);
+    }
+  }
+  //#region fields
+  allHttpMethods = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+  client;
+  server;
+  strategy;
+  /**
+   * global FE socket - only for established connection
+   */
+  conectSocketFE;
+  /**
+   * socket for namespaces and rooms
+   */
+  socketFE;
+  /**
+   * global BE socket - only for established connection
+   */
+  connectSocketBE;
+  /**
+   * socket for namespaces and rooms
+   */
+  socketBE;
+  //#endregion
+  //#region methods & getters / resovle staraegy
+  resolveStrategy() {
+    if (this.ctx.mode === "backend-frontend(websql)" || this.ctx.mode === "backend-frontend(websql-electron)") {
+      return new RealtimeStrategyMock(this.ctx);
+    }
+    if (this.ctx.mode === "backend-frontend(ipc-electron)") {
+      return new RealtimeStrategyIpc(this.ctx);
+    }
+    return new RealtimeStrategySocketIO(this.ctx);
+  }
+  //#endregion
+  //#region path for
+  pathFor(namespace) {
+    let nsp = namespace ? namespace : "";
+    nsp = nsp === "/" ? "" : nsp;
+    const contextNameForCommunication = this.ctx.contextNameForCommunication;
+    let prefix = `${apiPrefix}/${contextNameForCommunication}/udp`;
+    if (UtilsOs__NS__isElectron) {
+      prefix = ``;
+    }
+    const href = `${this.ctx.uriOrigin}${this.ctx.uriPathnameOrNothingIfRoot}/${prefix}${prefix && nsp ? "-" + nsp : nsp}`;
+    return new URL(href);
+  }
+  //#endregion
+}
+export {
+  RealtimeCore
+};