@tstdl/base 0.85.26 → 0.86.0-beta10

package/application/application.js

@@ -21,8 +21,11 @@ __export(application_exports, {
   Application: () => Application
 });
 module.exports = __toCommonJS(application_exports);
-var import_container = require("../container/index.js");
 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");
@@ -42,17 +45,7 @@ var __decorate = function(decorators, target, key, desc) {
         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 __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-};
 var Application_1;
-(0, import_process_shutdown.initializeSignals)();
 let Application = class Application2 {
   static {
     Application_1 = this;
@@ -60,27 +53,23 @@ let Application = class Application2 {
   static _instance;
   static get instance() {
     if ((0, import_type_guards.isUndefined)(this._instance)) {
-      this._instance = import_container.container.resolve(Application_1);
-      this._instance._shutdownToken = import_process_shutdown.shutdownToken;
+      this._instance = import_core.rootInjector.resolve(Application_1, "App");
+      this._instance.#shutdownToken = import_process_shutdown.shutdownToken;
     }
     return this._instance;
   }
-  logger;
-  moduleTypesAndInstances;
-  shutdownPromise;
-  _shutdownToken;
+  #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();
+    return this.#shutdownToken.asReadonly();
   }
   static get shutdownToken() {
     return Application_1.instance.shutdownToken;
   }
-  constructor(logger) {
-    this.logger = logger;
-    this.moduleTypesAndInstances = /* @__PURE__ */ new Set();
-    this.shutdownPromise = new import_deferred_promise.DeferredPromise();
-    this._shutdownToken = import_process_shutdown.shutdownToken.createChild();
-  }
   static registerModule(moduleType) {
     Application_1.instance.registerModule(moduleType);
   }
@@ -100,29 +89,31 @@ let Application = class Application2 {
     Application_1.instance.requestShutdown();
   }
   registerModule(moduleType) {
-    this.moduleTypesAndInstances.add(moduleType);
+    this.#moduleTypesAndInstances.add(moduleType);
   }
   registerModuleFunction(fn) {
     const module2 = new import_function_module.FunctionModule(fn);
     this.registerModule(module2);
   }
-  run(...functionsAndModules) {
-    void this._run(...functionsAndModules);
+  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;
+    await this.#shutdownPromise;
   }
   requestShutdown() {
     if (this.shutdownToken.isSet) {
       return;
     }
-    this._shutdownToken.set();
+    this.#shutdownToken.set();
   }
   async waitForShutdown() {
-    return this.shutdownPromise;
+    return this.#shutdownPromise;
   }
-  async _run(...functionsAndModules) {
+  async _run(functionsAndModules, options = {}) {
     for (const fnOrModule of functionsAndModules.flatMap((fns) => fns)) {
       if (fnOrModule.prototype instanceof import_module_base.ModuleBase) {
         this.registerModule(fnOrModule);
@@ -130,31 +121,35 @@ let Application = class Application2 {
         this.registerModuleFunction(fnOrModule);
       }
     }
-    const modules = await (0, import_to_array.toArrayAsync)((0, import_map.mapAsync)(this.moduleTypesAndInstances, async (instanceOrType) => (0, import_type_guards.isFunction)(instanceOrType) ? import_container.container.resolveAsync(instanceOrType) : instanceOrType));
+    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 });
+      this.#logger.error(error, { includeRest: true, includeStack: true });
     } finally {
       this.requestShutdown();
-      this.logger.info("Shutting down");
+      this.#logger.info("Shutting down");
       await this.stopModules(modules);
+      await this.#injector.dispose();
       await (0, import_core.disposeInstances)();
-      this.logger.info("Bye");
+      this.#logger.info("Bye");
     }
-    this.shutdownPromise.resolve();
+    this.#shutdownPromise.resolve();
   }
   async runModules(modules) {
     const promises = modules.map(async (module2) => {
       try {
-        this.logger.info(`Starting module ${module2.name}`);
-        await module2.run();
-        this.logger.info(`Module ${module2.name} stopped.`);
+        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.#logger.error(error);
         this.requestShutdown();
       }
     });
@@ -165,11 +160,11 @@ let Application = class Application2 {
       if (module2.state == import_module.ModuleState.Stopped) {
         return;
       }
-      this.logger.info(`Stopping module ${module2.name}`);
+      this.#logger.info(`Stopping module ${module2.name}`);
       try {
         await module2.stop();
       } catch (error) {
-        this.logger.error(error);
+        this.#logger.error(error);
         this.requestShutdown();
       }
     });
@@ -177,7 +172,5 @@ let Application = class Application2 {
   }
 };
 Application = Application_1 = __decorate([
-  (0, import_container.singleton)(),
-  __param(0, (0, import_container.resolveArg)("App")),
-  __metadata("design:paramtypes", [import_logger.Logger])
+  (0, import_decorators.Singleton)()
 ], Application);

package/authentication/client/api.client.js

@@ -23,8 +23,8 @@ __export(api_client_exports, {
 });
 module.exports = __toCommonJS(api_client_exports);
 var import_client = require("../../api/client/index.js");
-var import_container = require("../../container/index.js");
 var import_http_client = require("../../http/client/http-client.js");
+var import_injector = require("../../injector/index.js");
 var import_object = require("../../schema/schemas/object.js");
 var import_unknown = require("../../schema/schemas/unknown.js");
 var import_authentication_api = require("../authentication.api.js");
@@ -50,7 +50,7 @@ function getAuthenticationApiClient(additionalTokenPayloadSchema, authentication
     }
   };
   AuthenticationApiClient3 = __decorate([
-    (0, import_container.singleton)(),
+    (0, import_injector.Singleton)(),
     __metadata("design:paramtypes", [import_http_client.HttpClient])
   ], AuthenticationApiClient3);
   return AuthenticationApiClient3;
@@ -59,5 +59,5 @@ const defaultAuthenticationApiClient = getAuthenticationApiClient(import_object.
 let AuthenticationApiClient = class AuthenticationApiClient2 extends defaultAuthenticationApiClient {
 };
 AuthenticationApiClient = __decorate([
-  (0, import_container.replaceClass)(defaultAuthenticationApiClient)
+  (0, import_injector.ReplaceClass)(defaultAuthenticationApiClient)
 ], AuthenticationApiClient);

package/authentication/client/authentication.service.d.ts

@@ -1,16 +1,16 @@
+import type { Observable } from 'rxjs';
 import type { ApiClient } from '../../api/client/index.js';
-import type { AfterResolve } from '../../container/index.js';
-import { afterResolve } from '../../container/index.js';
 import type { AsyncDisposable } from '../../disposable/index.js';
 import { disposeAsync } from '../../disposable/index.js';
+import type { AfterResolve } from '../../injector/index.js';
+import { afterResolve } from '../../injector/index.js';
 import { Lock } from '../../lock/index.js';
 import { Logger } from '../../logger/index.js';
 import { MessageBus } from '../../message-bus/index.js';
 import type { Record } from '../../types.js';
-import type { Observable } from 'rxjs';
 import type { AuthenticationApiDefinition } from '../authentication.api.js';
 import type { SecretCheckResult, TokenPayload } from '../models/index.js';
-export declare class AuthenticationService<AdditionalTokenPayload extends Record = Record<never>, AuthenticationData = void> implements AfterResolve, AsyncDisposable {
+export declare class AuthenticationService<AdditionalTokenPayload extends Record = Record, AuthenticationData = any> implements AfterResolve, AsyncDisposable {
     private readonly client;
     private readonly errorSubject;
     private readonly tokenUpdateBus;

package/authentication/client/authentication.service.js

@@ -21,8 +21,7 @@ __export(authentication_service_exports, {
   AuthenticationService: () => AuthenticationService
 });
 module.exports = __toCommonJS(authentication_service_exports);
-var import_container = require("../../container/index.js");
-var import_core = require("../../core.js");
+var import_rxjs = require("rxjs");
 var import_disposable = require("../../disposable/index.js");
 var import_bad_request_error = require("../../error/bad-request.error.js");
 var import_forbidden_error = require("../../error/forbidden.error.js");
@@ -30,6 +29,7 @@ var import_invalid_token_error = require("../../error/invalid-token.error.js");
 var import_not_found_error = require("../../error/not-found.error.js");
 var import_not_supported_error = require("../../error/not-supported.error.js");
 var import_unauthorized_error = require("../../error/unauthorized.error.js");
+var import_injector = require("../../injector/index.js");
 var import_lock = require("../../lock/index.js");
 var import_logger = require("../../logger/index.js");
 var import_message_bus = require("../../message-bus/index.js");
@@ -38,7 +38,6 @@ var import_cancellation_token = require("../../utils/cancellation-token.js");
 var import_date_time = require("../../utils/date-time.js");
 var import_timing = require("../../utils/timing.js");
 var import_type_guards = require("../../utils/type-guards.js");
-var import_rxjs = require("rxjs");
 var import_tokens = require("./tokens.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;
@@ -64,6 +63,7 @@ const authenticationDataStorageKey = "AuthenticationService:authentication-data"
 const tokenUpdateBusName = "AuthenticationService:tokenUpdate";
 const loggedOutBusName = "AuthenticationService:loggedOut";
 const refreshLockResource = "AuthenticationService:refresh";
+const localStorage = globalThis.localStorage;
 let AuthenticationService = class AuthenticationService2 {
   client;
   errorSubject;
@@ -89,18 +89,18 @@ let AuthenticationService = class AuthenticationService2 {
   loggedOut$;
   get authenticationData() {
     try {
-      const data = localStorage.getItem(authenticationDataStorageKey);
-      return (0, import_type_guards.isNull)(data) ? void 0 : JSON.parse(data);
+      const data = localStorage?.getItem(authenticationDataStorageKey);
+      return (0, import_type_guards.isNullOrUndefined)(data) ? void 0 : JSON.parse(data);
     } catch {
       return void 0;
     }
   }
   set authenticationData(data) {
     if ((0, import_type_guards.isUndefined)(data)) {
-      localStorage.removeItem(authenticationDataStorageKey);
+      localStorage?.removeItem(authenticationDataStorageKey);
     } else {
       const json = JSON.stringify(data);
-      localStorage.setItem(authenticationDataStorageKey, json);
+      localStorage?.setItem(authenticationDataStorageKey, json);
     }
   }
   get definedToken() {
@@ -130,9 +130,8 @@ let AuthenticationService = class AuthenticationService2 {
     this.error$ = this.errorSubject.asObservable();
     this.loggedOut$ = loggedOutBus.allMessages$;
   }
-  [import_container.afterResolve]() {
+  [import_injector.afterResolve]() {
     this.initialize();
-    import_core.disposer.add(this);
   }
   initialize() {
     this.loadToken();
@@ -200,14 +199,14 @@ let AuthenticationService = class AuthenticationService2 {
       return;
     }
     if ((0, import_type_guards.isNullOrUndefined)(token)) {
-      localStorage.removeItem(tokenStorageKey);
+      localStorage?.removeItem(tokenStorageKey);
     } else {
       const serialized = JSON.stringify(token);
-      localStorage.setItem(tokenStorageKey, serialized);
+      localStorage?.setItem(tokenStorageKey, serialized);
     }
   }
   loadToken() {
-    if ((0, import_type_guards.isUndefined)(globalThis.localStorage)) {
+    if ((0, import_type_guards.isUndefined)(localStorage)) {
       return;
     }
     const existingSerializedToken = localStorage.getItem(tokenStorageKey);
@@ -252,15 +251,15 @@ let AuthenticationService = class AuthenticationService2 {
   }
 };
 AuthenticationService = __decorate([
-  (0, import_container.singleton)(),
-  __param(0, (0, import_container.inject)(import_tokens.AUTHENTICATION_API_CLIENT)),
-  __param(1, (0, import_container.resolveArg)(tokenUpdateBusName)),
-  __param(2, (0, import_container.resolveArg)(loggedOutBusName)),
-  __param(3, (0, import_container.inject)(import_lock.Lock, refreshLockResource)),
-  __param(3, (0, import_container.optional)()),
-  __param(4, (0, import_container.inject)(import_tokens.INITIAL_AUTHENTICATION_DATA)),
-  __param(4, (0, import_container.optional)()),
-  __param(5, (0, import_container.resolveArg)("AuthenticationService")),
+  (0, import_injector.Singleton)(),
+  __param(0, (0, import_injector.Inject)(import_tokens.AUTHENTICATION_API_CLIENT)),
+  __param(1, (0, import_injector.ResolveArg)(tokenUpdateBusName)),
+  __param(2, (0, import_injector.ResolveArg)(loggedOutBusName)),
+  __param(3, (0, import_injector.Inject)(import_lock.Lock, refreshLockResource)),
+  __param(3, (0, import_injector.Optional)()),
+  __param(4, (0, import_injector.Inject)(import_tokens.INITIAL_AUTHENTICATION_DATA)),
+  __param(4, (0, import_injector.Optional)()),
+  __param(5, (0, import_injector.ResolveArg)("AuthenticationService")),
   __metadata("design:paramtypes", [
     void 0,
     import_message_bus.MessageBus,

package/authentication/client/http-client.middleware.d.ts

@@ -1,5 +1,3 @@
-import type { HttpClientMiddleware } from '../../http/client/http-client.js';
-import { AuthenticationService } from './authentication.service.js';
-export type AuthenticationServiceProvider = () => (AuthenticationService<any, any> | Promise<AuthenticationService<any, any>>);
-export declare const defaultAuthenticationServiceProvider: () => Promise<AuthenticationService<import("../../types.js").Record, unknown>>;
-export declare function waitForAuthenticationCredentialsMiddleware(authenticationService?: AuthenticationService | AuthenticationServiceProvider): HttpClientMiddleware;
+import type { HttpClientMiddleware } from '../../http/client/middleware.js';
+import type { AuthenticationService } from './authentication.service.js';
+export declare function waitForAuthenticationCredentialsMiddleware(authenticationService: AuthenticationService): HttpClientMiddleware;

package/authentication/client/http-client.middleware.js

@@ -18,26 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var http_client_middleware_exports = {};
 __export(http_client_middleware_exports, {
-  defaultAuthenticationServiceProvider: () => defaultAuthenticationServiceProvider,
   waitForAuthenticationCredentialsMiddleware: () => waitForAuthenticationCredentialsMiddleware
 });
 module.exports = __toCommonJS(http_client_middleware_exports);
-var import_container = require("../../container/index.js");
-var import_type_guards = require("../../utils/type-guards.js");
 var import_rxjs = require("rxjs");
 var import_authentication_api = require("../authentication.api.js");
-var import_authentication_service = require("./authentication.service.js");
-const defaultAuthenticationServiceProvider = async () => import_container.container.resolveAsync(import_authentication_service.AuthenticationService);
-function waitForAuthenticationCredentialsMiddleware(authenticationService = defaultAuthenticationServiceProvider) {
-  let service = (0, import_type_guards.isNotFunction)(authenticationService) ? authenticationService : void 0;
+function waitForAuthenticationCredentialsMiddleware(authenticationService) {
   async function waitForAuthenticationCredentialsMiddleware2(request, next, context) {
     const endpoint = context?.endpoint;
     if (endpoint?.credentials == true && endpoint.data?.[import_authentication_api.dontWaitForValidToken] != true) {
-      if ((0, import_type_guards.isUndefined)(service)) {
-        service = await (0, import_type_guards.assertFunctionPass)(authenticationService)();
-      }
-      while (!service.hasValidToken) {
-        await (0, import_rxjs.firstValueFrom)(service.validToken$);
+      while (!authenticationService.hasValidToken) {
+        await (0, import_rxjs.firstValueFrom)(authenticationService.validToken$);
       }
     }
     return next(request);

package/authentication/client/module.d.ts

@@ -1,4 +1,5 @@
 import type { ApiClientImplementation } from '../../api/index.js';
+import { Injector } from '../../injector/injector.js';
 import type { Type } from '../../types.js';
 import type { AuthenticationApiDefinition } from '../authentication.api.js';
 export type AuthenticationModuleConfig = {
@@ -6,4 +7,4 @@ export type AuthenticationModuleConfig = {
     initialAuthenticationData?: unknown;
     registerMiddleware?: boolean;
 };
-export declare function configureAuthenticationClient(config?: AuthenticationModuleConfig): void;
+export declare function configureAuthenticationClient(config: AuthenticationModuleConfig, injector?: Injector | null): void;

package/authentication/client/module.js

@@ -21,19 +21,27 @@ __export(module_exports, {
   configureAuthenticationClient: () => configureAuthenticationClient
 });
 module.exports = __toCommonJS(module_exports);
-var import_container = require("../../container/index.js");
-var import_module = require("../../http/client/module.js");
+var import_tokens = require("../../http/client/tokens.js");
+var import_inject = require("../../injector/inject.js");
+var import_injector = require("../../injector/injector.js");
 var import_type_guards = require("../../utils/type-guards.js");
+var import_authentication_service = require("./authentication.service.js");
 var import_http_client_middleware = require("./http-client.middleware.js");
-var import_tokens = require("./tokens.js");
-function configureAuthenticationClient(config = {}) {
+var import_tokens2 = require("./tokens.js");
+function configureAuthenticationClient(config, injector = (0, import_inject.getCurrentInjector)()) {
   if ((0, import_type_guards.isDefined)(config.authenticationApiClient)) {
-    import_container.container.registerSingleton(import_tokens.AUTHENTICATION_API_CLIENT, { useToken: config.authenticationApiClient });
+    (injector ?? import_injector.Injector).registerSingleton(import_tokens2.AUTHENTICATION_API_CLIENT, { useToken: config.authenticationApiClient });
   }
   if ((0, import_type_guards.isDefined)(config.initialAuthenticationData)) {
-    import_container.container.register(import_tokens.INITIAL_AUTHENTICATION_DATA, { useValue: config.initialAuthenticationData });
+    (injector ?? import_injector.Injector).register(import_tokens2.INITIAL_AUTHENTICATION_DATA, { useValue: config.initialAuthenticationData });
   }
   if ((0, import_type_guards.isDefined)(config.registerMiddleware)) {
-    (0, import_module.configureHttpClient)({ middleware: [(0, import_http_client_middleware.waitForAuthenticationCredentialsMiddleware)()] });
+    (0, import_type_guards.assertNotNull)(injector);
+    injector.register(import_tokens.HTTP_CLIENT_MIDDLEWARE, {
+      useFactory(_, context) {
+        const authenticationService = context.resolve(import_authentication_service.AuthenticationService);
+        return (0, import_http_client_middleware.waitForAuthenticationCredentialsMiddleware)(authenticationService);
+      }
+    });
   }
 }

package/authentication/client/tokens.d.ts

@@ -1,4 +1,4 @@
 import type { ApiClientImplementation } from '../../api/index.js';
 import type { AuthenticationApiDefinition } from '../authentication.api.js';
-export declare const AUTHENTICATION_API_CLIENT: import("../../container/index.js").InjectionToken<ApiClientImplementation<AuthenticationApiDefinition<any, any>>, any>;
-export declare const INITIAL_AUTHENTICATION_DATA: import("../../container/index.js").InjectionToken<unknown, any>;
+export declare const AUTHENTICATION_API_CLIENT: import("../../injector/token.js").InjectionToken<ApiClientImplementation<AuthenticationApiDefinition<any, any>>, never>;
+export declare const INITIAL_AUTHENTICATION_DATA: import("../../injector/token.js").InjectionToken<unknown, never>;

package/authentication/client/tokens.js

@@ -22,8 +22,9 @@ __export(tokens_exports, {
   INITIAL_AUTHENTICATION_DATA: () => INITIAL_AUTHENTICATION_DATA
 });
 module.exports = __toCommonJS(tokens_exports);
-var import_container = require("../../container/index.js");
+var import_injector = require("../../injector/injector.js");
+var import_token = require("../../injector/token.js");
 var import_api_client = require("./api.client.js");
-const AUTHENTICATION_API_CLIENT = (0, import_container.injectionToken)("ApiClientImplementation");
-const INITIAL_AUTHENTICATION_DATA = (0, import_container.injectionToken)("initial authentication data");
-import_container.container.registerSingleton(AUTHENTICATION_API_CLIENT, { useToken: import_api_client.AuthenticationApiClient });
+const AUTHENTICATION_API_CLIENT = (0, import_token.injectionToken)("ApiClientImplementation");
+const INITIAL_AUTHENTICATION_DATA = (0, import_token.injectionToken)("initial authentication data");
+import_injector.Injector.registerSingleton(AUTHENTICATION_API_CLIENT, { useToken: import_api_client.AuthenticationApiClient });

package/authentication/server/authentication-api-request-token.provider.js

@@ -22,7 +22,7 @@ __export(authentication_api_request_token_provider_exports, {
 });
 module.exports = __toCommonJS(authentication_api_request_token_provider_exports);
 var import_api_request_token_provider = require("../../api/server/api-request-token.provider.js");
-var import_container = require("../../container/index.js");
+var import_decorators = require("../../injector/decorators.js");
 var import_authentication_service = require("./authentication.service.js");
 var import_helper = require("./helper.js");
 var __decorate = function(decorators, target, key, desc) {
@@ -52,6 +52,6 @@ let AuthenticationApiRequestTokenProvider = class AuthenticationApiRequestTokenP
   }
 };
 AuthenticationApiRequestTokenProvider = __decorate([
-  (0, import_container.singleton)(),
+  (0, import_decorators.Singleton)(),
   __metadata("design:paramtypes", [import_authentication_service.AuthenticationService])
 ], AuthenticationApiRequestTokenProvider);

package/authentication/server/authentication-secret-requirements.validator.js

@@ -22,7 +22,7 @@ __export(authentication_secret_requirements_validator_exports, {
   DefaultAuthenticationSecretRequirementsValidator: () => DefaultAuthenticationSecretRequirementsValidator
 });
 module.exports = __toCommonJS(authentication_secret_requirements_validator_exports);
-var import_decorators = require("../../container/decorators.js");
+var import_injector = require("../../injector/index.js");
 var import_password_check_result_model = require("../../password/password-check-result.model.js");
 var import_password_check = require("../../password/password-check.js");
 var import_type_guards = require("../../utils/type-guards.js");
@@ -61,5 +61,5 @@ let DefaultAuthenticationSecretRequirementsValidator = class DefaultAuthenticati
   }
 };
 DefaultAuthenticationSecretRequirementsValidator = __decorate([
-  (0, import_decorators.singleton)({ alias: AuthenticationSecretRequirementsValidator })
+  (0, import_injector.Singleton)({ alias: AuthenticationSecretRequirementsValidator })
 ], DefaultAuthenticationSecretRequirementsValidator);

package/authentication/server/authentication.service.d.ts

@@ -1,5 +1,5 @@
-import type { AfterResolve } from '../../container/index.js';
-import { afterResolve } from '../../container/index.js';
+import type { AfterResolve } from '../../injector/index.js';
+import { afterResolve } from '../../injector/index.js';
 import type { Record } from '../../types.js';
 import type { RefreshToken, SecretCheckResult, SecretResetToken, Token } from '../models/index.js';
 import { AuthenticationCredentialsRepository } from './authentication-credentials.repository.js';

package/authentication/server/authentication.service.js

@@ -22,9 +22,9 @@ __export(authentication_service_exports, {
   AuthenticationServiceOptions: () => AuthenticationServiceOptions
 });
 module.exports = __toCommonJS(authentication_service_exports);
-var import_container = require("../../container/index.js");
 var import_invalid_token_error = require("../../error/invalid-token.error.js");
 var import_not_implemented_error = require("../../error/not-implemented.error.js");
+var import_injector = require("../../injector/index.js");
 var import_alphabet = require("../../utils/alphabet.js");
 var import_cryptography = require("../../utils/cryptography.js");
 var import_date_time = require("../../utils/date-time.js");
@@ -104,7 +104,7 @@ let AuthenticationService = class AuthenticationService2 {
     this.refreshTokenTimeToLive = options.refreshTokenTimeToLive ?? 5 * import_units.millisecondsPerDay;
     this.secretResetTokenTimeToLive = options.secretResetTokenTimeToLive ?? 10 * import_units.millisecondsPerMinute;
   }
-  async [import_container.afterResolve]() {
+  async [import_injector.afterResolve]() {
     await this.initialize();
   }
   async initialize() {
@@ -304,13 +304,13 @@ let AuthenticationService = class AuthenticationService2 {
   }
 };
 AuthenticationService = __decorate([
-  (0, import_container.singleton)(),
-  __param(3, (0, import_container.inject)(import_authentication_subject_resolver.AuthenticationSubjectResolver)),
-  __param(3, (0, import_container.optional)()),
-  __param(4, (0, import_container.inject)(import_authentication_token_payload_provider.AuthenticationTokenPayloadProvider)),
-  __param(4, (0, import_container.optional)()),
-  __param(5, (0, import_container.inject)(import_authentication_secret_reset_handler.AuthenticationSecretResetHandler)),
-  __param(5, (0, import_container.optional)()),
+  (0, import_injector.Singleton)(),
+  __param(3, (0, import_injector.Inject)(import_authentication_subject_resolver.AuthenticationSubjectResolver)),
+  __param(3, (0, import_injector.Optional)()),
+  __param(4, (0, import_injector.Inject)(import_authentication_token_payload_provider.AuthenticationTokenPayloadProvider)),
+  __param(4, (0, import_injector.Optional)()),
+  __param(5, (0, import_injector.Inject)(import_authentication_secret_reset_handler.AuthenticationSecretResetHandler)),
+  __param(5, (0, import_injector.Optional)()),
   __metadata("design:paramtypes", [
     import_authentication_credentials_repository.AuthenticationCredentialsRepository,
     import_authentication_session_repository.AuthenticationSessionRepository,

package/authentication/server/module.d.ts

@@ -1,4 +1,5 @@
-import type { InjectionToken, Provider } from '../../container/index.js';
+import type { Provider } from '../../injector/provider.js';
+import type { InjectionToken } from '../../injector/token.js';
 import { AuthenticationCredentialsRepository } from './authentication-credentials.repository.js';
 import { AuthenticationSessionRepository } from './authentication-session.repository.js';
 import { AuthenticationSubjectResolver } from './authentication-subject.resolver.js';

package/authentication/server/module.js

@@ -21,7 +21,8 @@ __export(module_exports, {
   configureAuthenticationServer: () => configureAuthenticationServer
 });
 module.exports = __toCommonJS(module_exports);
-var import_container = require("../../container/index.js");
+var import_injector = require("../../injector/injector.js");
+var import_provider = require("../../injector/provider.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_authentication_credentials_repository = require("./authentication-credentials.repository.js");
 var import_authentication_session_repository = require("./authentication-session.repository.js");
@@ -30,19 +31,19 @@ var import_authentication_token_payload_provider = require("./authentication-tok
 var import_authentication_service = require("./authentication.service.js");
 function configureAuthenticationServer(config) {
   if ((0, import_type_guards.isDefined)(config.serviceOptions)) {
-    import_container.container.register(import_authentication_service.AuthenticationServiceOptions, (0, import_container.isProvider)(config.serviceOptions) ? config.serviceOptions : { useValue: config.serviceOptions });
+    import_injector.Injector.register(import_authentication_service.AuthenticationServiceOptions, (0, import_provider.isProvider)(config.serviceOptions) ? config.serviceOptions : { useValue: config.serviceOptions });
   } else {
     throw new Error("Either serviceOptions or serviceOptionsToken must be provided.");
   }
-  import_container.container.registerSingleton(import_authentication_credentials_repository.AuthenticationCredentialsRepository, { useToken: config.credentialsRepository });
-  import_container.container.registerSingleton(import_authentication_session_repository.AuthenticationSessionRepository, { useToken: config.sessionRepository });
+  import_injector.Injector.registerSingleton(import_authentication_credentials_repository.AuthenticationCredentialsRepository, { useToken: config.credentialsRepository });
+  import_injector.Injector.registerSingleton(import_authentication_session_repository.AuthenticationSessionRepository, { useToken: config.sessionRepository });
   if ((0, import_type_guards.isDefined)(config.authenticationService)) {
-    import_container.container.registerSingleton(import_authentication_service.AuthenticationService, { useToken: config.authenticationService });
+    import_injector.Injector.registerSingleton(import_authentication_service.AuthenticationService, { useToken: config.authenticationService });
   }
   if ((0, import_type_guards.isDefined)(config.tokenPayloadProvider)) {
-    import_container.container.registerSingleton(import_authentication_token_payload_provider.AuthenticationTokenPayloadProvider, { useToken: config.tokenPayloadProvider });
+    import_injector.Injector.registerSingleton(import_authentication_token_payload_provider.AuthenticationTokenPayloadProvider, { useToken: config.tokenPayloadProvider });
   }
   if ((0, import_type_guards.isDefined)(config.subjectResolver)) {
-    import_container.container.registerSingleton(import_authentication_subject_resolver.AuthenticationSubjectResolver, { useToken: config.subjectResolver });
+    import_injector.Injector.registerSingleton(import_authentication_subject_resolver.AuthenticationSubjectResolver, { useToken: config.subjectResolver });
   }
 }

package/authentication/server/mongo/mongo-authentication-credentials.repository.d.ts

@@ -1,14 +1,14 @@
-import type { Injectable } from '../../../container/index.js';
-import { type resolveArgumentType } from '../../../container/index.js';
 import type { MaybeNewEntity } from '../../../database/index.js';
 import type { CollectionArgument } from '../../../database/mongo/index.js';
 import { Collection, MongoEntityRepository } from '../../../database/mongo/index.js';
+import { resolveArgumentType } from '../../../injector/index.js';
+import type { Resolvable } from '../../../injector/interfaces.js';
 import { Logger } from '../../../logger/index.js';
 import type { AuthenticationCredentials, NewAuthenticationCredentials } from '../../models/index.js';
 import { AuthenticationCredentialsRepository } from '../authentication-credentials.repository.js';
 export type MongoAuthenticationCredentialsRepositoryArgument = CollectionArgument<AuthenticationCredentials>;
 export type MongoAuthenticationCredentialsRepositoryConfig = MongoAuthenticationCredentialsRepositoryArgument;
-export declare class InternalMongoAuthenticationCredentialsRepository extends MongoEntityRepository<AuthenticationCredentials> implements Injectable<MongoAuthenticationCredentialsRepositoryArgument> {
+export declare class InternalMongoAuthenticationCredentialsRepository extends MongoEntityRepository<AuthenticationCredentials> implements Resolvable<MongoAuthenticationCredentialsRepositoryArgument> {
     readonly [resolveArgumentType]: MongoAuthenticationCredentialsRepositoryArgument;
     constructor(collection: Collection<AuthenticationCredentials>, logger: Logger);
     upsert(credentials: MaybeNewEntity<AuthenticationCredentials>): Promise<void>;

package/authentication/server/mongo/mongo-authentication-credentials.repository.js

@@ -23,9 +23,9 @@ __export(mongo_authentication_credentials_repository_exports, {
   configureMongoAuthenticationCredentialsRepository: () => configureMongoAuthenticationCredentialsRepository
 });
 module.exports = __toCommonJS(mongo_authentication_credentials_repository_exports);
-var import_container = require("../../../container/index.js");
 var import_database = require("../../../database/index.js");
 var import_mongo = require("../../../database/mongo/index.js");
+var import_injector = require("../../../injector/index.js");
 var import_logger = require("../../../logger/index.js");
 var import_type_guards = require("../../../utils/type-guards.js");
 var import_authentication_credentials_repository = require("../authentication-credentials.repository.js");
@@ -62,10 +62,10 @@ let InternalMongoAuthenticationCredentialsRepository = class InternalMongoAuthen
   }
 };
 InternalMongoAuthenticationCredentialsRepository = __decorate([
-  (0, import_container.singleton)({
+  (0, import_injector.Singleton)({
     defaultArgumentProvider: () => defaultArgument
   }),
-  __param(0, (0, import_container.forwardArg)()),
+  __param(0, (0, import_injector.ForwardArg)()),
   __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
 ], InternalMongoAuthenticationCredentialsRepository);
 let MongoAuthenticationCredentialsRepository = class MongoAuthenticationCredentialsRepository2 extends import_authentication_credentials_repository.AuthenticationCredentialsRepository {
@@ -90,7 +90,7 @@ let MongoAuthenticationCredentialsRepository = class MongoAuthenticationCredenti
   }
 };
 MongoAuthenticationCredentialsRepository = __decorate([
-  (0, import_container.singleton)(),
+  (0, import_injector.Singleton)(),
   __metadata("design:paramtypes", [InternalMongoAuthenticationCredentialsRepository])
 ], MongoAuthenticationCredentialsRepository);
 function configureMongoAuthenticationCredentialsRepository(config) {