taon 21.0.51 → 21.0.53

package/lib-prod/create-context.js

@@ -0,0 +1,152 @@
+import { ___NS__isString, Helpers__NS__log, UtilsOs__NS__isRunningInDocker } from "tnp-core/lib-prod";
+import { EndpointContext } from "./endpoint-context";
+import { ContextsEndpointStorage } from "./endpoint-context-storage";
+const createContextTemplate = (configFn) => {
+  return () => {
+    return createContext(configFn);
+  };
+};
+const createContextFn = (configFn, cloneOptions) => {
+  cloneOptions = cloneOptions || {};
+  let config = configFn({});
+  const endpointContextRef = new EndpointContext(
+    config,
+    configFn,
+    cloneOptions
+  );
+  const res = {
+    //#region contexts
+    get contextName() {
+      return config.contextName;
+    },
+    //#endregion
+    get appId() {
+      return config.appId;
+    },
+    cloneAsRemote: (cloneOpt) => {
+      cloneOpt = cloneOpt || {};
+      const opt = {
+        ...cloneOpt,
+        sourceContext: endpointContextRef,
+        useAsRemoteContext: true
+      };
+      return createContextFn(configFn, opt);
+    },
+    cloneAsNormal: (cloneOpt) => {
+      cloneOpt = cloneOpt || {};
+      const opt = {
+        ...cloneOpt,
+        sourceContext: endpointContextRef,
+        useAsRemoteContext: false
+      };
+      return createContextFn(configFn, opt);
+    },
+    //#region context
+    /**
+     * @deprecated
+     * - get reference to internal context
+     */
+    async __ref() {
+      if (!endpointContextRef.inited) {
+        await endpointContextRef.init({
+          initFromRecrusiveContextResovle: true
+        });
+      }
+      return endpointContextRef;
+    },
+    /**
+     * only for internal use
+     * @deprecated
+     */
+    get __refSync() {
+      return endpointContextRef;
+    },
+    getClassInstance(ctor) {
+      return endpointContextRef.getInstanceBy(ctor);
+    },
+    getClass(ctor) {
+      const classFun = endpointContextRef.getClassFunByClass(ctor);
+      return classFun;
+    },
+    //#endregion
+    //#region initialize
+    /**
+     * - create controller instances for context
+     * - init database (if enable) + migation scripts
+     */
+    initialize: async (overrideOptions) => {
+      return await new Promise(async (resolve, reject) => {
+        setTimeout(async () => {
+          if (UtilsOs__NS__isRunningInDocker()) {
+            const activeContext = config?.activeContext || null;
+            if (___NS__isString(activeContext) && activeContext !== "" && activeContext !== config?.contextName) {
+              console.warn(
+                `[taon] Context ${endpointContextRef.contextName} is not active context, skipping initialization.`
+              );
+              resolve(endpointContextRef);
+              return;
+            }
+          }
+          await endpointContextRef.init({
+            ...overrideOptions
+          });
+          if (config.abstract) {
+            throw new Error(`Abstract context can not be initialized`);
+          }
+          await endpointContextRef.initEntities();
+          await endpointContextRef.initSubscribers();
+          await endpointContextRef.initDatabaseConnection();
+          await endpointContextRef.dbMigrations.ensureMigrationTableExists();
+          await endpointContextRef.initControllers();
+          await endpointContextRef.startServer();
+          endpointContextRef.writeActiveRoutes();
+          await endpointContextRef.initClasses();
+          if (endpointContextRef.databaseConfig) {
+            if (endpointContextRef.onlyMigrationRun) {
+              endpointContextRef.logMigrations && Helpers__NS__log(
+                `[taon] Running only migrations (context=${endpointContextRef.contextName}).`
+              );
+              await endpointContextRef.dbMigrations.runAllNotCompletedMigrations();
+            } else if (endpointContextRef.onlyMigrationRevertToTimestamp) {
+              endpointContextRef.logMigrations && Helpers__NS__log(
+                `[taon] Reverting migrations to timestamp ${endpointContextRef.onlyMigrationRevertToTimestamp} (context=${endpointContextRef.contextName}).`
+              );
+              await endpointContextRef.dbMigrations.revertMigrationToTimestamp(
+                endpointContextRef.onlyMigrationRevertToTimestamp
+              );
+            } else {
+              endpointContextRef.logMigrations && Helpers__NS__log(
+                `[taon] Running all not applied migrations (context=${endpointContextRef.contextName}).`
+              );
+              await endpointContextRef.dbMigrations.runAllNotCompletedMigrations();
+            }
+          }
+          ContextsEndpointStorage.Instance.set(endpointContextRef);
+          resolve(endpointContextRef);
+        });
+      });
+    },
+    /**
+     * realtime communication with server
+     * TCP(upgrade) socket.io (or ipc) based.
+     */
+    get realtime() {
+      return {
+        get client() {
+          return endpointContextRef.realtimeClient;
+        },
+        get server() {
+          return endpointContextRef.realtimeServer;
+        }
+      };
+    }
+  };
+  return res;
+};
+const createContext = (configFn) => {
+  return createContextFn(configFn, { useAsRemoteContext: false });
+};
+export {
+  createContext,
+  createContextTemplate
+};

package/lib-prod/decorators/classes/controller-decorator.js

@@ -0,0 +1,21 @@
+import { ClassHelpers__NS__ensureClassConfig, ClassHelpers__NS__setName } from "../../helpers/class-helpers";
+import { Symbols__NS__metadata } from "../../symbols";
+function TaonController(options) {
+  return function(constructor) {
+    ClassHelpers__NS__setName(constructor, options?.className);
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.className,
+      options?.className || constructor.name,
+      constructor
+    );
+    const cfg = ClassHelpers__NS__ensureClassConfig(constructor);
+    options = options || {};
+    cfg.className = options.className || constructor.name;
+    cfg.path = options.path || "";
+    cfg.realtime = options.realtime;
+    cfg.middlewares = options.middlewares;
+  };
+}
+export {
+  TaonController
+};

package/lib-prod/decorators/classes/entity-decorator.js

@@ -0,0 +1,49 @@
+import { Mapping__NS__DefaultModelWithMapping } from "ng2-rest/lib-prod";
+import { Entity } from "taon-typeorm/lib-prod";
+import { ___NS__merge } from "tnp-core/lib-prod";
+import { CLASS } from "typescript-class-helpers/lib-prod";
+import { ClassHelpers__NS__setName } from "../../helpers/class-helpers";
+import { Symbols__NS__metadata } from "../../symbols";
+import { DecoratorAbstractOpt } from "../decorator-abstract-opt";
+function TaonEntity(options) {
+  return function(constructor) {
+    options = options || {};
+    options.uniqueKeyProp = options.uniqueKeyProp || "id";
+    ClassHelpers__NS__setName(constructor, options?.className);
+    Mapping__NS__DefaultModelWithMapping(
+      options?.defaultModelValues || {},
+      ___NS__merge(
+        options?.defaultModelMapping || {},
+        options?.defaultModelMappingDeep || {}
+      )
+    )(constructor);
+    Mapping__NS__DefaultModelWithMapping(void 0, {})(constructor);
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.options.entity,
+      options,
+      constructor
+    );
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.className,
+      options?.className || constructor.name,
+      constructor
+    );
+    Entity(options?.className)(constructor);
+    CLASS.setName(constructor, options?.className);
+  };
+}
+class TaonEntityOptions extends DecoratorAbstractOpt {
+  /**
+   * default unique property is "id"
+   * for your entity it may be something else
+   */
+  uniqueKeyProp;
+  createTable;
+  defaultModelValues;
+  defaultModelMapping;
+  defaultModelMappingDeep;
+}
+export {
+  TaonEntity,
+  TaonEntityOptions
+};

package/lib-prod/decorators/classes/middleware-decorator.js

@@ -0,0 +1,26 @@
+import "reflect-metadata";
+import { ClassHelpers__NS__setName } from "../../helpers/class-helpers";
+import { Symbols__NS__metadata } from "../../symbols";
+import { DecoratorAbstractOpt } from "../decorator-abstract-opt";
+function TaonMiddleware(options) {
+  return function(constructor) {
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.options.provider,
+      options,
+      constructor
+    );
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.className,
+      options?.className || constructor.name,
+      constructor
+    );
+    ClassHelpers__NS__setName(constructor, options?.className || constructor.name);
+  };
+}
+class TaonMiddlewareOptions extends DecoratorAbstractOpt {
+  // middleware is a singleton for each context
+}
+export {
+  TaonMiddleware,
+  TaonMiddlewareOptions
+};

package/lib-prod/decorators/classes/migration-decorator.js

@@ -0,0 +1,24 @@
+import { ClassHelpers__NS__setName } from "../../helpers/class-helpers";
+import { Symbols__NS__metadata } from "../../symbols";
+import { DecoratorAbstractOpt } from "../decorator-abstract-opt";
+function TaonMigration(options) {
+  return function(constructor) {
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.options.migration,
+      options,
+      constructor
+    );
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.className,
+      options?.className || constructor.name,
+      constructor
+    );
+    ClassHelpers__NS__setName(constructor, options?.className);
+  };
+}
+class TaonMigrationOptions extends DecoratorAbstractOpt {
+}
+export {
+  TaonMigration,
+  TaonMigrationOptions
+};

package/lib-prod/decorators/classes/provider-decorator.js

@@ -0,0 +1,25 @@
+import { ClassHelpers__NS__setName } from "../../helpers/class-helpers";
+import { Symbols__NS__metadata } from "../../symbols";
+import { DecoratorAbstractOpt } from "../decorator-abstract-opt";
+function TaonProvider(options) {
+  return function(constructor) {
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.options.provider,
+      options,
+      constructor
+    );
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.className,
+      options?.className || constructor.name,
+      constructor
+    );
+    ClassHelpers__NS__setName(constructor, options?.className || constructor.name);
+  };
+}
+class TaonProviderOptions extends DecoratorAbstractOpt {
+  // providers is a singleton for each context
+}
+export {
+  TaonProvider,
+  TaonProviderOptions
+};

package/lib-prod/decorators/classes/repository-decorator.js

@@ -0,0 +1,24 @@
+import { ClassHelpers__NS__setName } from "../../helpers/class-helpers";
+import { Symbols__NS__metadata } from "../../symbols";
+import { DecoratorAbstractOpt } from "../decorator-abstract-opt";
+function TaonRepository(options) {
+  return function(constructor) {
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.options.repository,
+      options,
+      constructor
+    );
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.className,
+      options?.className || constructor.name,
+      constructor
+    );
+    ClassHelpers__NS__setName(constructor, options?.className);
+  };
+}
+class TaonRepositoryOptions extends DecoratorAbstractOpt {
+}
+export {
+  TaonRepository,
+  TaonRepositoryOptions
+};

package/lib-prod/decorators/classes/subscriber-decorator.js

@@ -0,0 +1,25 @@
+import { ClassHelpers__NS__setName } from "../../helpers/class-helpers";
+import { Symbols__NS__metadata } from "../../symbols";
+import { DecoratorAbstractOpt } from "../decorator-abstract-opt";
+function TaonSubscriber(options) {
+  return function(constructor) {
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.options.subscriber,
+      options,
+      constructor
+    );
+    Reflect.defineMetadata(
+      Symbols__NS__metadata.className,
+      options?.className || constructor.name,
+      constructor
+    );
+    ClassHelpers__NS__setName(constructor, options?.className);
+  };
+}
+class TaonSubscriberOptions extends DecoratorAbstractOpt {
+  allowedEvents;
+}
+export {
+  TaonSubscriber,
+  TaonSubscriberOptions
+};

package/lib-prod/decorators/decorator-abstract-opt.js

@@ -0,0 +1,5 @@
+class DecoratorAbstractOpt {
+}
+export {
+  DecoratorAbstractOpt
+};

package/lib-prod/decorators/http/http-decorators.js

@@ -0,0 +1,5 @@
+import { Models__NS__HttpResponse } from "ng2-rest/lib-prod";
+const HttpResponse = Models__NS__HttpResponse;
+export {
+  HttpResponse
+};

package/lib-prod/decorators/http/http-methods-decorators.js

@@ -0,0 +1,144 @@
+import { ___NS__isString } from "tnp-core/lib-prod";
+import { ClassHelpers__NS__ensureMethodConfig } from "../../helpers/class-helpers";
+const metaReq = (method, path, target, propertyKey, descriptor, pathOrOptions, pathIsGlobal) => {
+  const methodConfig = ClassHelpers__NS__ensureMethodConfig(target, propertyKey);
+  let options;
+  if (typeof pathOrOptions === "object") {
+    options = pathOrOptions;
+    pathOrOptions = options.path;
+    pathIsGlobal = !!options.pathIsGlobal;
+    path = options.path;
+  } else {
+    options = { pathOrOptions, pathIsGlobal };
+  }
+  const {
+    overrideContentType,
+    overrideResponseType,
+    overrideExpressSendAsHtml,
+    middlewares
+  } = options;
+  methodConfig.methodName = propertyKey;
+  methodConfig.middlewares = middlewares;
+  methodConfig.type = method;
+  if (!path) {
+    let paramsPathConcatedPath = "";
+    for (const key in methodConfig.parameters) {
+      if (methodConfig.parameters.hasOwnProperty(key)) {
+        const element = methodConfig.parameters[key];
+        if (element.paramType === "Path" && ___NS__isString(element.paramName) && element.paramName.trim().length > 0) {
+          paramsPathConcatedPath += `/${element.paramName}/:${element.paramName}`;
+        }
+      }
+    }
+    methodConfig.path = `/${propertyKey}${paramsPathConcatedPath}`;
+  } else {
+    methodConfig.path = path;
+  }
+  methodConfig.descriptor = descriptor;
+  methodConfig.global = pathIsGlobal;
+  methodConfig.contentType = overrideContentType;
+  methodConfig.responseType = overrideResponseType;
+  methodConfig.overrideExpressSendAsHtml = overrideExpressSendAsHtml;
+};
+function GET(pathOrOptions, pathIsGlobal = false) {
+  return function(target, propertyKey, descriptor) {
+    metaReq(
+      "get",
+      pathOrOptions,
+      target,
+      propertyKey,
+      descriptor,
+      pathOrOptions,
+      pathIsGlobal
+    );
+  };
+}
+function HTML(pathOrOptions) {
+  return function(target, propertyKey, descriptor) {
+    const opt = pathOrOptions;
+    opt.overrideExpressSendAsHtml = true;
+    metaReq(
+      "get",
+      opt,
+      target,
+      propertyKey,
+      descriptor,
+      pathOrOptions,
+      opt.pathIsGlobal
+    );
+  };
+}
+function HEAD(pathOrOptions, pathIsGlobal = false) {
+  return function(target, propertyKey, descriptor) {
+    metaReq(
+      "head",
+      pathOrOptions,
+      target,
+      propertyKey,
+      descriptor,
+      pathOrOptions,
+      pathIsGlobal
+    );
+  };
+}
+function POST(pathOrOptions, pathIsGlobal = false) {
+  return function(target, propertyKey, descriptor) {
+    metaReq(
+      "post",
+      pathOrOptions,
+      target,
+      propertyKey,
+      descriptor,
+      pathOrOptions,
+      pathIsGlobal
+    );
+  };
+}
+function PUT(pathOrOptions, pathIsGlobal = false) {
+  return function(target, propertyKey, descriptor) {
+    metaReq(
+      "put",
+      pathOrOptions,
+      target,
+      propertyKey,
+      descriptor,
+      pathOrOptions,
+      pathIsGlobal
+    );
+  };
+}
+function PATCH(pathOrOptions, pathIsGlobal = false) {
+  return function(target, propertyKey, descriptor) {
+    metaReq(
+      "patch",
+      pathOrOptions,
+      target,
+      propertyKey,
+      descriptor,
+      pathOrOptions,
+      pathIsGlobal
+    );
+  };
+}
+function DELETE(pathOrOptions, pathIsGlobal = false) {
+  return function(target, propertyKey, descriptor) {
+    metaReq(
+      "delete",
+      pathOrOptions,
+      target,
+      propertyKey,
+      descriptor,
+      pathOrOptions,
+      pathIsGlobal
+    );
+  };
+}
+export {
+  DELETE,
+  GET,
+  HEAD,
+  HTML,
+  PATCH,
+  POST,
+  PUT
+};

package/lib-prod/decorators/http/http-params-decorators.js

@@ -0,0 +1,68 @@
+import { ClassHelpers__NS__ensureMethodConfig } from "../../helpers/class-helpers";
+function metaParam(param, name, expire, defaultValue = void 0, target, propertyKey, parameterIndex) {
+  const methodCfg = ClassHelpers__NS__ensureMethodConfig(target, propertyKey);
+  const nameKey = name ? name : param;
+  methodCfg.parameters[nameKey] = {
+    index: parameterIndex,
+    paramName: name,
+    paramType: param,
+    defaultType: defaultValue,
+    expireInSeconds: expire
+  };
+}
+function Path(name) {
+  return function(target, propertyKey, parameterIndex) {
+    metaParam("Path", name, void 0, {}, target, propertyKey, parameterIndex);
+  };
+}
+function Query(name) {
+  return function(target, propertyKey, parameterIndex) {
+    metaParam(
+      "Query",
+      name,
+      void 0,
+      {},
+      target,
+      propertyKey,
+      parameterIndex
+    );
+  };
+}
+function Cookie(name, expireInSecond = 3600) {
+  return function(target, propertyKey, parameterIndex) {
+    metaParam(
+      "Cookie",
+      name,
+      expireInSecond,
+      {},
+      target,
+      propertyKey,
+      parameterIndex
+    );
+  };
+}
+function Header(name) {
+  return function(target, propertyKey, parameterIndex) {
+    metaParam(
+      "Header",
+      name,
+      void 0,
+      {},
+      target,
+      propertyKey,
+      parameterIndex
+    );
+  };
+}
+function Body(name) {
+  return function(target, propertyKey, parameterIndex) {
+    metaParam("Body", name, void 0, {}, target, propertyKey, parameterIndex);
+  };
+}
+export {
+  Body,
+  Cookie,
+  Header,
+  Path,
+  Query
+};

package/lib-prod/dependency-injection/di-container.js

@@ -0,0 +1,31 @@
+class DITaonContainer {
+  static instances = /* @__PURE__ */ new Map();
+  static resolve(target) {
+    if (DITaonContainer.instances.has(target)) {
+      return DITaonContainer.instances.get(target);
+    }
+    const injections = [];
+    const instance = new target(...injections);
+    DITaonContainer.instances.set(target, instance);
+    return instance;
+  }
+  static inject(target) {
+    return new Proxy(
+      {},
+      {
+        get: (_, propName) => {
+          let instance = DITaonContainer.instances.get(target) || DITaonContainer.resolve(target);
+          return typeof instance[propName] === "function" ? instance[propName].bind(instance) : instance[propName];
+        },
+        set: (_, propName, value) => {
+          let instance = DITaonContainer.instances.get(target) || DITaonContainer.resolve(target);
+          instance[propName] = value;
+          return true;
+        }
+      }
+    );
+  }
+}
+export {
+  DITaonContainer
+};

package/lib-prod/endpoint-context-storage.js

@@ -0,0 +1,36 @@
+import { CoreModels__NS__SPECIAL_APP_READY_MESSAGE } from "tnp-core/lib-prod";
+class ContextsEndpointStorage {
+  SPECIAL_APP_READY_MESSAGE = CoreModels__NS__SPECIAL_APP_READY_MESSAGE;
+  taonEndpointContexts = /* @__PURE__ */ new Map();
+  //#region singleton
+  static instance;
+  constructor() {
+  }
+  static get Instance() {
+    if (!ContextsEndpointStorage.instance) {
+      ContextsEndpointStorage.instance = new ContextsEndpointStorage();
+    }
+    return ContextsEndpointStorage.instance;
+  }
+  //#endregion
+  set(context) {
+    if (!this.taonEndpointContexts.has(context.contextName)) {
+      this.taonEndpointContexts.set(context.contextName, context);
+    }
+  }
+  get arr() {
+    return Array.from(this.taonEndpointContexts.values()).filter(
+      (f) => f.contextType === "normal"
+    );
+  }
+  getBy(context) {
+    if (typeof context === "string") {
+      return this.taonEndpointContexts.get(context);
+    }
+    return this.taonEndpointContexts.get(context.contextName);
+  }
+}
+globalThis["$$$ContextsEndpointStorage$$$"] = ContextsEndpointStorage.Instance;
+export {
+  ContextsEndpointStorage
+};