@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/application/application.js

@@ -1,163 +1,176 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var application_exports = {};
+__export(application_exports, {
+  Application: () => Application
+});
+module.exports = __toCommonJS(application_exports);
+var import_core = require("../core.js");
+var import_decorators = require("../injector/decorators.js");
+var import_inject = require("../injector/inject.js");
+var import_injector = require("../injector/injector.js");
+var import_interfaces = require("../injector/interfaces.js");
+var import_logger = require("../logger/index.js");
+var import_module_base = require("../module/module-base.js");
+var import_module = require("../module/module.js");
+var import_function_module = require("../module/modules/function.module.js");
+var import_process_shutdown = require("../process-shutdown.js");
+var import_deferred_promise = require("../promise/deferred-promise.js");
+var import_map = require("../utils/async-iterable-helpers/map.js");
+var import_to_array = require("../utils/async-iterable-helpers/to-array.js");
+var import_type_guards = require("../utils/type-guards.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 var Application_1;
-import { container, resolveArg, singleton } from '../container/index.js';
-import { disposeInstances } from '../core.js';
-import { Logger } from '../logger/index.js';
-import { ModuleBase } from '../module/module-base.js';
-import { ModuleState } from '../module/module.js';
-import { FunctionModule } from '../module/modules/function.module.js';
-import { initializeSignals, shutdownToken } from '../process-shutdown.js';
-import { DeferredPromise } from '../promise/deferred-promise.js';
-import { mapAsync } from '../utils/async-iterable-helpers/map.js';
-import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
-import { isFunction, isUndefined } from '../utils/type-guards.js';
-/**
- * TODO
- *
- * container scopes
- * dispose per container
- */
-initializeSignals();
-export let Application = class Application {
-    static { Application_1 = this; }
-    static _instance;
-    static get instance() {
-        if (isUndefined(this._instance)) {
-            this._instance = container.resolve(Application_1);
-            // @ts-expect-error readonly
-            this._instance._shutdownToken = shutdownToken;
-        }
-        return this._instance;
-    }
-    logger;
-    moduleTypesAndInstances;
-    shutdownPromise;
-    _shutdownToken;
-    get shutdownToken() {
-        return this._shutdownToken.asReadonly();
-    }
-    static get shutdownToken() {
-        return Application_1.instance.shutdownToken;
-    }
-    constructor(logger) {
-        this.logger = logger;
-        this.moduleTypesAndInstances = new Set();
-        this.shutdownPromise = new DeferredPromise();
-        this._shutdownToken = shutdownToken.createChild();
-    }
-    static registerModule(moduleType) {
-        Application_1.instance.registerModule(moduleType);
-    }
-    static registerModuleFunction(fn) {
-        Application_1.instance.registerModuleFunction(fn);
-    }
-    static run(...functionsAndModules) {
-        Application_1.instance.run(...functionsAndModules);
-    }
-    static async waitForShutdown() {
-        return Application_1.instance.waitForShutdown();
-    }
-    static async shutdown() {
-        await Application_1.instance.shutdown();
-    }
-    static requestShutdown() {
-        Application_1.instance.requestShutdown();
-    }
-    registerModule(moduleType) {
-        this.moduleTypesAndInstances.add(moduleType);
-    }
-    registerModuleFunction(fn) {
-        const module = new FunctionModule(fn);
-        this.registerModule(module);
-    }
-    run(...functionsAndModules) {
-        void this._run(...functionsAndModules);
-    }
-    async shutdown() {
+let Application = class Application2 {
+  static {
+    Application_1 = this;
+  }
+  static _instance;
+  static get instance() {
+    if ((0, import_type_guards.isUndefined)(this._instance)) {
+      this._instance = import_core.rootInjector.resolve(Application_1, "App");
+      this._instance.#shutdownToken = import_process_shutdown.shutdownToken;
+    }
+    return this._instance;
+  }
+  #name = (0, import_inject.injectArgument)(this);
+  #injector = (0, import_inject.inject)(import_injector.Injector).fork(`${this.#name}Injector`);
+  #logger = this.#injector.resolve(import_logger.Logger, this.#name);
+  #moduleTypesAndInstances = /* @__PURE__ */ new Set();
+  #shutdownPromise = new import_deferred_promise.DeferredPromise();
+  #shutdownToken = import_process_shutdown.shutdownToken.createChild();
+  get shutdownToken() {
+    return this.#shutdownToken.asReadonly();
+  }
+  static get shutdownToken() {
+    return Application_1.instance.shutdownToken;
+  }
+  static registerModule(moduleType) {
+    Application_1.instance.registerModule(moduleType);
+  }
+  static registerModuleFunction(fn) {
+    Application_1.instance.registerModuleFunction(fn);
+  }
+  static run(...functionsAndModules) {
+    Application_1.instance.run(...functionsAndModules);
+  }
+  static async waitForShutdown() {
+    return Application_1.instance.waitForShutdown();
+  }
+  static async shutdown() {
+    await Application_1.instance.shutdown();
+  }
+  static requestShutdown() {
+    Application_1.instance.requestShutdown();
+  }
+  registerModule(moduleType) {
+    this.#moduleTypesAndInstances.add(moduleType);
+  }
+  registerModuleFunction(fn) {
+    const module2 = new import_function_module.FunctionModule(fn);
+    this.registerModule(module2);
+  }
+  run(...optionsFunctionsAndModules) {
+    const options = optionsFunctionsAndModules.length > 0 && (0, import_type_guards.isObject)(optionsFunctionsAndModules[0]) ? optionsFunctionsAndModules[0] : void 0;
+    const functionsAndModules = (0, import_type_guards.isUndefined)(options) ? optionsFunctionsAndModules : optionsFunctionsAndModules.slice(1);
+    void this._run(functionsAndModules, options);
+  }
+  async shutdown() {
+    this.requestShutdown();
+    await this.#shutdownPromise;
+  }
+  requestShutdown() {
+    if (this.shutdownToken.isSet) {
+      return;
+    }
+    this.#shutdownToken.set();
+  }
+  async waitForShutdown() {
+    return this.#shutdownPromise;
+  }
+  async _run(functionsAndModules, options = {}) {
+    for (const fnOrModule of functionsAndModules.flatMap((fns) => fns)) {
+      if (fnOrModule.prototype instanceof import_module_base.ModuleBase) {
+        this.registerModule(fnOrModule);
+      } else {
+        this.registerModuleFunction(fnOrModule);
+      }
+    }
+    if ((0, import_type_guards.isDefined)(options.bootstrap)) {
+      await (0, import_inject.runInInjectionContext)(this.#injector, options.bootstrap);
+    }
+    const modules = await (0, import_to_array.toArrayAsync)((0, import_map.mapAsync)(this.#moduleTypesAndInstances, async (instanceOrType) => (0, import_type_guards.isFunction)(instanceOrType) ? this.#injector.resolveAsync(instanceOrType) : instanceOrType));
+    try {
+      await Promise.race([
+        this.runModules(modules),
+        this.shutdownToken
+      ]);
+    } catch (error) {
+      this.#logger.error(error, { includeRest: true, includeStack: true });
+    } finally {
+      this.requestShutdown();
+      this.#logger.info("Shutting down");
+      await this.stopModules(modules);
+      await this.#injector.dispose();
+      await (0, import_core.disposeInstances)();
+      this.#logger.info("Bye");
+    }
+    this.#shutdownPromise.resolve();
+  }
+  async runModules(modules) {
+    const promises = modules.map(async (module2) => {
+      try {
+        this.#logger.info(`Starting module ${module2.name}`);
+        await (0, import_inject.runInInjectionContext)(this.#injector, async () => module2.run());
+        this.#logger.info(`Module ${module2.name} stopped.`);
+      } catch (error) {
+        this.#logger.error(error);
         this.requestShutdown();
-        await this.shutdownPromise;
-    }
-    requestShutdown() {
-        if (this.shutdownToken.isSet) {
-            return;
-        }
-        this._shutdownToken.set();
-    }
-    async waitForShutdown() {
-        return this.shutdownPromise;
-    }
-    async _run(...functionsAndModules) {
-        for (const fnOrModule of functionsAndModules.flatMap((fns) => fns)) {
-            if (fnOrModule.prototype instanceof ModuleBase) {
-                this.registerModule(fnOrModule);
-            }
-            else {
-                this.registerModuleFunction(fnOrModule);
-            }
-        }
-        const modules = await toArrayAsync(mapAsync(this.moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? container.resolveAsync(instanceOrType) : instanceOrType)));
-        try {
-            await Promise.race([
-                this.runModules(modules),
-                this.shutdownToken
-            ]);
-        }
-        catch (error) {
-            this.logger.error(error, { includeRest: true, includeStack: true });
-        }
-        finally {
-            this.requestShutdown();
-            this.logger.info('Shutting down');
-            await this.stopModules(modules);
-            await disposeInstances();
-            this.logger.info('Bye');
-        }
-        this.shutdownPromise.resolve();
-    }
-    async runModules(modules) {
-        const promises = modules.map(async (module) => {
-            try {
-                this.logger.info(`Starting module ${module.name}`);
-                await module.run();
-                this.logger.info(`Module ${module.name} stopped.`);
-            }
-            catch (error) {
-                this.logger.error(error);
-                this.requestShutdown();
-            }
-        });
-        await Promise.all(promises);
-    }
-    async stopModules(modules) {
-        const promises = modules.map(async (module) => {
-            if (module.state == ModuleState.Stopped) {
-                return;
-            }
-            this.logger.info(`Stopping module ${module.name}`);
-            try {
-                await module.stop();
-            }
-            catch (error) {
-                this.logger.error(error);
-                this.requestShutdown();
-            }
-        });
-        await Promise.all(promises);
-    }
+      }
+    });
+    await Promise.all(promises);
+  }
+  async stopModules(modules) {
+    const promises = modules.map(async (module2) => {
+      if (module2.state == import_module.ModuleState.Stopped) {
+        return;
+      }
+      this.#logger.info(`Stopping module ${module2.name}`);
+      try {
+        await module2.stop();
+      } catch (error) {
+        this.#logger.error(error);
+        this.requestShutdown();
+      }
+    });
+    await Promise.all(promises);
+  }
 };
 Application = Application_1 = __decorate([
-    singleton(),
-    __param(0, resolveArg('App')),
-    __metadata("design:paramtypes", [Logger])
+  (0, import_decorators.Singleton)()
 ], Application);

package/application/index.js

@@ -1 +1,18 @@
-export * from './application.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var application_exports = {};
+module.exports = __toCommonJS(application_exports);
+__reExport(application_exports, require("./application.js"), module.exports);

package/async-iterator-symbol.js

@@ -1,6 +1,29 @@
-export function polyfillAsyncIteratorSymbol() {
-    const hasAsyncIteratorSymbol = 'asyncIterator' in Symbol;
-    if (!hasAsyncIteratorSymbol) {
-        Symbol.asyncIterator = Symbol.for('Symbol.asyncIterator');
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var async_iterator_symbol_exports = {};
+__export(async_iterator_symbol_exports, {
+  polyfillAsyncIteratorSymbol: () => polyfillAsyncIteratorSymbol
+});
+module.exports = __toCommonJS(async_iterator_symbol_exports);
+function polyfillAsyncIteratorSymbol() {
+  const hasAsyncIteratorSymbol = "asyncIterator" in Symbol;
+  if (!hasAsyncIteratorSymbol) {
+    Symbol.asyncIterator = Symbol.for("Symbol.asyncIterator");
+  }
 }

package/authentication/authentication.api.js

@@ -1,91 +1,115 @@
-import { defineApi } from '../api/types.js';
-import { assign } from '../schema/schemas/assign.js';
-import { literal } from '../schema/schemas/literal.js';
-import { number } from '../schema/schemas/number.js';
-import { emptyObjectSchema, explicitObject, object } from '../schema/schemas/object.js';
-import { string } from '../schema/schemas/string.js';
-import { unknown } from '../schema/schemas/unknown.js';
-import { SecretCheckResult } from './models/secret-check-result.model.js';
-import { TokenPayloadBase } from './models/token-payload-base.model.js';
-export const dontWaitForValidToken = Symbol('dontWaitForValidToken');
-export const authenticationApiDefinition = getAuthenticationApiDefinition(emptyObjectSchema, unknown());
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function getAuthenticationApiDefinition(additionalTokenPayloadSchema, authenticationDataSchema, resource, additionalEndpoints) {
-    return defineApi({
-        resource: resource ?? 'auth',
-        endpoints: {
-            ...getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSchema, authenticationDataSchema),
-            ...additionalEndpoints
-        }
-    });
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var authentication_api_exports = {};
+__export(authentication_api_exports, {
+  authenticationApiDefinition: () => authenticationApiDefinition,
+  dontWaitForValidToken: () => dontWaitForValidToken,
+  getAuthenticationApiDefinition: () => getAuthenticationApiDefinition,
+  getAuthenticationApiEndpointsDefinition: () => getAuthenticationApiEndpointsDefinition
+});
+module.exports = __toCommonJS(authentication_api_exports);
+var import_types = require("../api/types.js");
+var import_assign = require("../schema/schemas/assign.js");
+var import_literal = require("../schema/schemas/literal.js");
+var import_number = require("../schema/schemas/number.js");
+var import_object = require("../schema/schemas/object.js");
+var import_string = require("../schema/schemas/string.js");
+var import_unknown = require("../schema/schemas/unknown.js");
+var import_secret_check_result_model = require("./models/secret-check-result.model.js");
+var import_token_payload_base_model = require("./models/token-payload-base.model.js");
+const dontWaitForValidToken = Symbol("dontWaitForValidToken");
+const authenticationApiDefinition = getAuthenticationApiDefinition(import_object.emptyObjectSchema, (0, import_unknown.unknown)());
+function getAuthenticationApiDefinition(additionalTokenPayloadSchema, authenticationDataSchema, resource, additionalEndpoints) {
+  return (0, import_types.defineApi)({
+    resource: resource ?? "auth",
+    endpoints: {
+      ...getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSchema, authenticationDataSchema),
+      ...additionalEndpoints
+    }
+  });
 }
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSchema, authenticationDataSchema) {
-    const tokenResultSchema = assign(TokenPayloadBase, additionalTokenPayloadSchema);
-    return {
-        token: {
-            resource: 'token',
-            method: 'POST',
-            parameters: explicitObject({
-                subject: string(),
-                secret: string(),
-                data: authenticationDataSchema
-            }),
-            result: tokenResultSchema,
-            credentials: true,
-            data: {
-                [dontWaitForValidToken]: true
-            }
-        },
-        refresh: {
-            resource: 'refresh',
-            method: 'POST',
-            parameters: explicitObject({
-                data: authenticationDataSchema
-            }),
-            result: tokenResultSchema,
-            credentials: true,
-            data: {
-                [dontWaitForValidToken]: true
-            }
-        },
-        endSession: {
-            resource: 'end-session',
-            method: 'POST',
-            result: literal('ok'),
-            credentials: true,
-            data: {
-                [dontWaitForValidToken]: true
-            }
-        },
-        initResetSecret: {
-            resource: 'secret/init-reset',
-            method: 'POST',
-            parameters: object({
-                subject: string()
-            }),
-            result: literal('ok')
-        },
-        resetSecret: {
-            resource: 'secret/reset',
-            method: 'POST',
-            parameters: object({
-                token: string(),
-                newSecret: string()
-            }),
-            result: literal('ok')
-        },
-        checkSecret: {
-            resource: 'secret/check',
-            method: 'POST',
-            parameters: object({
-                secret: string()
-            }),
-            result: SecretCheckResult
-        },
-        timestamp: {
-            resource: 'timestamp',
-            result: number()
-        }
-    };
+function getAuthenticationApiEndpointsDefinition(additionalTokenPayloadSchema, authenticationDataSchema) {
+  const tokenResultSchema = (0, import_assign.assign)(import_token_payload_base_model.TokenPayloadBase, additionalTokenPayloadSchema);
+  return {
+    token: {
+      resource: "token",
+      method: "POST",
+      parameters: (0, import_object.explicitObject)({
+        subject: (0, import_string.string)(),
+        secret: (0, import_string.string)(),
+        data: authenticationDataSchema
+      }),
+      result: tokenResultSchema,
+      credentials: true,
+      data: {
+        [dontWaitForValidToken]: true
+      }
+    },
+    refresh: {
+      resource: "refresh",
+      method: "POST",
+      parameters: (0, import_object.explicitObject)({
+        data: authenticationDataSchema
+      }),
+      result: tokenResultSchema,
+      credentials: true,
+      data: {
+        [dontWaitForValidToken]: true
+      }
+    },
+    endSession: {
+      resource: "end-session",
+      method: "POST",
+      result: (0, import_literal.literal)("ok"),
+      credentials: true,
+      data: {
+        [dontWaitForValidToken]: true
+      }
+    },
+    initResetSecret: {
+      resource: "secret/init-reset",
+      method: "POST",
+      parameters: (0, import_object.object)({
+        subject: (0, import_string.string)()
+      }),
+      result: (0, import_literal.literal)("ok")
+    },
+    resetSecret: {
+      resource: "secret/reset",
+      method: "POST",
+      parameters: (0, import_object.object)({
+        token: (0, import_string.string)(),
+        newSecret: (0, import_string.string)()
+      }),
+      result: (0, import_literal.literal)("ok")
+    },
+    checkSecret: {
+      resource: "secret/check",
+      method: "POST",
+      parameters: (0, import_object.object)({
+        secret: (0, import_string.string)()
+      }),
+      result: import_secret_check_result_model.SecretCheckResult
+    },
+    timestamp: {
+      resource: "timestamp",
+      result: (0, import_number.number)()
+    }
+  };
 }