@tstdl/base 0.87.13 → 0.88.0-alpha1

package/application/application.js

@@ -1,175 +1,153 @@
-"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 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 __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;
 };
 var Application_1;
-let Application = class Application2 {
-  static {
-    Application_1 = this;
-  }
-  static _instance;
-  static get instance() {
-    if ((0, import_type_guards.isUndefined)(this._instance)) {
-      this._instance = (0, import_core.getGlobalInjector)().resolve(Application_1, "App");
-      this._instance.#shutdownToken = (0, import_process_shutdown.getShutdownToken)();
-    }
-    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 = (0, import_process_shutdown.getShutdownSignal)().createChild();
-  get shutdownSignal() {
-    return this.#shutdownToken.signal;
-  }
-  static get shutdownSignal() {
-    return Application_1.instance.shutdownSignal;
-  }
-  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.shutdownSignal.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.shutdownSignal
-      ]);
-    } 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();
-      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 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);
+import { getGlobalInjector } from '../core.js';
+import { Singleton } from '../injector/decorators.js';
+import { inject, injectArgument, runInInjectionContext } from '../injector/inject.js';
+import { Injector } from '../injector/injector.js';
+import { resolveArgumentType } from '../injector/interfaces.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 { getShutdownSignal, getShutdownToken } 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 { isDefined, isFunction, isObject, isUndefined } from '../utils/type-guards.js';
+let Application = class Application {
+    static { Application_1 = this; }
+    static _instance;
+    static get instance() {
+        if (isUndefined(this._instance)) {
+            this._instance = getGlobalInjector().resolve(Application_1, 'App');
+            // @ts-expect-error readonly
+            this._instance.#shutdownToken = getShutdownToken();
+        }
+        return this._instance;
+    }
+    #name = injectArgument(this);
+    #injector = inject(Injector).fork(`${this.#name}Injector`);
+    #logger = this.#injector.resolve(Logger, this.#name);
+    #moduleTypesAndInstances = new Set();
+    #shutdownPromise = new DeferredPromise();
+    #shutdownToken = getShutdownSignal().createChild();
+    get shutdownSignal() {
+        return this.#shutdownToken.signal;
+    }
+    static get shutdownSignal() {
+        return Application_1.instance.shutdownSignal;
+    }
+    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(...optionsFunctionsAndModules) {
+        const options = ((optionsFunctionsAndModules.length > 0) && isObject(optionsFunctionsAndModules[0])) ? optionsFunctionsAndModules[0] : undefined;
+        const functionsAndModules = (isUndefined(options) ? optionsFunctionsAndModules : optionsFunctionsAndModules.slice(1));
+        void this._run(functionsAndModules, options);
+    }
+    async shutdown() {
         this.requestShutdown();
-      }
-    });
-    await Promise.all(promises);
-  }
+        await this.#shutdownPromise;
+    }
+    requestShutdown() {
+        if (this.shutdownSignal.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 ModuleBase) {
+                this.registerModule(fnOrModule);
+            }
+            else {
+                this.registerModuleFunction(fnOrModule);
+            }
+        }
+        if (isDefined(options.bootstrap)) {
+            await runInInjectionContext(this.#injector, options.bootstrap);
+        }
+        const modules = await toArrayAsync(mapAsync(this.#moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? this.#injector.resolveAsync(instanceOrType) : instanceOrType)));
+        try {
+            await Promise.race([
+                this.runModules(modules),
+                this.shutdownSignal
+            ]);
+        }
+        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();
+            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 runInInjectionContext(this.#injector, async () => 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);
+    }
 };
 Application = Application_1 = __decorate([
-  (0, import_decorators.Singleton)()
+    Singleton()
 ], Application);
+export { Application };

package/application/index.js

@@ -1,18 +1 @@
-"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);
+export * from './application.js';

package/async-iterator-symbol.js

@@ -1,29 +1,6 @@
-"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");
-  }
+export function polyfillAsyncIteratorSymbol() {
+    const hasAsyncIteratorSymbol = 'asyncIterator' in Symbol;
+    if (!hasAsyncIteratorSymbol) {
+        Symbol.asyncIterator = Symbol.for('Symbol.asyncIterator');
+    }
 }

package/authentication/authentication.api.js

@@ -1,115 +1,91 @@
-"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
-    }
-  });
+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
+        }
+    });
 }
-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)()
-    }
-  };
+// 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()
+        }
+    };
 }