@tstdl/base 0.85.26 → 0.86.0-beta10

package/_container/decorators.d.ts

@@ -0,0 +1,76 @@
+import type { Decorator } from '../reflection/index.js';
+import type { Constructor, OneOrMany, Simplify, TypedOmit } from '../types.js';
+import type { RegistrationOptions } from './container.js';
+import type { Provider } from './provider.js';
+import type { InjectionToken } from './token.js';
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
+type InjectDecorator = Decorator<'property' | 'accessor' | 'constructorParameter'>;
+export type InjectableOptions<T, A> = RegistrationOptions<T> & {
+    /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
+    alias?: OneOrMany<InjectionToken>;
+    /** custom provider. Useful for example if initialization is required */
+    provider?: Provider<T, A>;
+};
+export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
+/**
+ * Helper decorator to replace a class definition with an other
+ * can be used for example to type external classes with the {@link Injectable} interface
+ * @param constructor class to replace with
+ */
+export declare function replaceClass<T>(constructor: Constructor<T>): ClassDecorator;
+/**
+ * registers the class in the global container. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function injectable<T = any, A = any>(options?: InjectableOptions<T, A>): ClassDecorator;
+/**
+ * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
+ * @param options registration options
+ */
+export declare function scoped<T = any, A = any>(lifecycle: 'resolution', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
+/**
+ * sets the token used to resolve the parameter
+ * @param token token used for resolving
+ * @param argument resolve argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * sets the argument used for resolving the parameter
+ * @param argument
+ */
+export declare function resolveArg<T>(argument: T): InjectDecorator;
+/**
+ * sets the argument provider used for resolving the parameter
+ * @param argumentProvider
+ */
+export declare function resolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
+/**
+ * injects the argument used for resolving the class instead of resolving the parameter
+ * @param argument
+ * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
+ */
+export declare function injectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
+/**
+ * sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
+ * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
+ */
+export declare function forwardArg(): InjectDecorator;
+export declare function forwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
+/**
+ * marks the argument as optional
+ * @param argument
+ */
+export declare function optional(): InjectDecorator;
+/**
+ * resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
+ * @param token token to resolve
+ * @param argument resolve argument
+ */
+export declare function forwardRef<T extends object, A>(token: ForwardRefInjectionToken<T>, argument?: A): InjectDecorator;
+export {};

package/_container/decorators.js

@@ -0,0 +1,110 @@
+"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 decorators_exports = {};
+__export(decorators_exports, {
+  forwardArg: () => forwardArg,
+  forwardRef: () => forwardRef,
+  inject: () => inject,
+  injectArg: () => injectArg,
+  injectable: () => injectable,
+  optional: () => optional,
+  replaceClass: () => replaceClass,
+  resolveArg: () => resolveArg,
+  resolveArgProvider: () => resolveArgProvider,
+  scoped: () => scoped,
+  singleton: () => singleton
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_reflection = require("../reflection/index.js");
+var import_array = require("../utils/array/array.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_container = require("./container.js");
+function replaceClass(constructor) {
+  return (0, import_reflection.createClassDecorator)({ handler: () => constructor });
+}
+function injectable(options = {}) {
+  return (0, import_reflection.createClassDecorator)({
+    data: { [import_container.injectMetadataSymbol]: {} },
+    mergeData: true,
+    handler: (data) => {
+      const { alias: aliases, provider, ...registrationOptions } = options;
+      const targetProvider = provider ?? { useClass: data.constructor };
+      import_container.container.register(data.constructor, targetProvider, registrationOptions);
+      if ((0, import_type_guards.isDefined)(aliases)) {
+        for (const alias of (0, import_array.toArray)(aliases)) {
+          import_container.container.register(alias, { useToken: data.constructor }, registrationOptions);
+        }
+      }
+    }
+  });
+}
+function singleton(options = {}) {
+  return injectable({ ...options, lifecycle: "singleton" });
+}
+function scoped(lifecycle, options = {}) {
+  return injectable({ ...options, lifecycle });
+}
+function inject(token, argument, mapperOrKey) {
+  const injectMetadata = {};
+  if ((0, import_type_guards.isDefined)(token)) {
+    injectMetadata.injectToken = token;
+  }
+  if ((0, import_type_guards.isDefined)(argument)) {
+    injectMetadata.resolveArgumentProvider = () => argument;
+  }
+  if ((0, import_type_guards.isDefined)(mapperOrKey)) {
+    injectMetadata.mapper = (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (value) => value[mapperOrKey];
+  }
+  return createInjectDecorator(injectMetadata);
+}
+function resolveArg(argument) {
+  return resolveArgProvider(() => argument);
+}
+function resolveArgProvider(argumentProvider) {
+  return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
+}
+function injectArg(mapperOrKey) {
+  return createInjectDecorator({
+    injectArgumentMapper: (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (0, import_type_guards.isDefined)(mapperOrKey) ? (value) => value[mapperOrKey] : (value) => value
+  });
+}
+function forwardArg(mapper = (value) => value) {
+  return createInjectDecorator({ forwardArgumentMapper: mapper });
+}
+function optional() {
+  return createInjectDecorator({ optional: true });
+}
+function forwardRef(token, argument) {
+  const injectMetadata = {
+    forwardRefToken: token
+  };
+  if ((0, import_type_guards.isDefined)(argument)) {
+    injectMetadata.resolveArgumentProvider = () => argument;
+  }
+  return createInjectDecorator(injectMetadata);
+}
+function createInjectDecorator(metadata) {
+  return (0, import_reflection.createDecorator)({
+    property: true,
+    accessor: true,
+    constructorParameter: true,
+    data: { [import_container.injectMetadataSymbol]: metadata },
+    mergeData: true
+  });
+}

package/_container/index.d.ts

@@ -0,0 +1,10 @@
+export * from './container.js';
+export * from './decorators.js';
+export * from './interfaces.js';
+export * from './provider.js';
+export * from './resolve-chain.js';
+export * from './resolve.error.js';
+export * from './token.js';
+export * from './type-info.js';
+export * from './types.js';
+export * from './utils.js';

package/_container/index.js

@@ -0,0 +1,27 @@
+"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 container_exports = {};
+module.exports = __toCommonJS(container_exports);
+__reExport(container_exports, require("./container.js"), module.exports);
+__reExport(container_exports, require("./decorators.js"), module.exports);
+__reExport(container_exports, require("./interfaces.js"), module.exports);
+__reExport(container_exports, require("./provider.js"), module.exports);
+__reExport(container_exports, require("./resolve-chain.js"), module.exports);
+__reExport(container_exports, require("./resolve.error.js"), module.exports);
+__reExport(container_exports, require("./token.js"), module.exports);
+__reExport(container_exports, require("./type-info.js"), module.exports);
+__reExport(container_exports, require("./types.js"), module.exports);
+__reExport(container_exports, require("./utils.js"), module.exports);

package/_container/interfaces.d.ts

@@ -0,0 +1,16 @@
+export declare const resolveArgumentType: unique symbol;
+export declare const afterResolve: unique symbol;
+export type InjectableArgument<T, Fallback> = T extends Injectable<infer A> ? A : Fallback;
+export interface Injectable<T = unknown> {
+    /**
+     * type of resolve argument
+     * @deprecated only used for type inference
+     */
+    readonly [resolveArgumentType]: T;
+}
+export interface AfterResolve {
+    /**
+     * called after resolve through container
+     */
+    [afterResolve](): void | Promise<void>;
+}

package/_container/interfaces.js

@@ -0,0 +1,26 @@
+"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 interfaces_exports = {};
+__export(interfaces_exports, {
+  afterResolve: () => afterResolve,
+  resolveArgumentType: () => resolveArgumentType
+});
+module.exports = __toCommonJS(interfaces_exports);
+const resolveArgumentType = Symbol("resolveArgumentType");
+const afterResolve = Symbol("after resolve");

package/_container/token.d.ts

@@ -0,0 +1,18 @@
+import type { AbstractConstructor, EnumerationObject } from '../types.js';
+declare const type: unique symbol;
+declare const argument: unique symbol;
+export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
+    [argument]?: A;
+};
+export type SimpleInjectionToken<T> = AbstractConstructor<T> | EnumerationObject;
+export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
+export declare class ReifyingInjectionToken<T = any, A = any> {
+    private readonly [type];
+    private readonly [argument];
+    readonly description: string;
+    constructor(description: string);
+    toString(): string;
+}
+export declare function injectionToken<T, A = any>(description: string): InjectionToken<T, A>;
+export declare function getTokenName(token: InjectionToken | undefined): string;
+export {};

package/_container/token.js

@@ -0,0 +1,41 @@
+"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 token_exports = {};
+__export(token_exports, {
+  ReifyingInjectionToken: () => ReifyingInjectionToken,
+  getTokenName: () => getTokenName,
+  injectionToken: () => injectionToken
+});
+module.exports = __toCommonJS(token_exports);
+var import_type_guards = require("../utils/type-guards.js");
+class ReifyingInjectionToken {
+  description;
+  constructor(description) {
+    this.description = description;
+  }
+  toString() {
+    return `InjectionToken["${this.description}"]`;
+  }
+}
+function injectionToken(description) {
+  return new ReifyingInjectionToken(description);
+}
+function getTokenName(token) {
+  return (0, import_type_guards.isFunction)(token) ? token.name : (0, import_type_guards.isString)(token) ? `"${token}"` : String(token);
+}

package/api/client/client.d.ts

@@ -1,8 +1,8 @@
-import type { Injectable } from '../../container/index.js';
 import type { HttpClientOptions } from '../../http/client/index.js';
 import { HttpClient } from '../../http/client/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
 import type { ApiClientImplementation, ApiDefinition, ApiEndpointDefinition } from '../types.js';
-export type ApiClient<T extends ApiDefinition> = new (httpClient: HttpClient) => ApiClientImplementation<T> & Injectable<HttpClientOptions>;
+export type ApiClient<T extends ApiDefinition> = new (httpClient: HttpClient) => ApiClientImplementation<T> & Resolvable<HttpClientOptions>;
 export type ClientOptions = {
     /**
      * url prefix

package/api/client/client.js

@@ -23,9 +23,11 @@ __export(client_exports, {
   httpClientSymbol: () => httpClientSymbol
 });
 module.exports = __toCommonJS(client_exports);
-var import_container = require("../../container/index.js");
 var import_client = require("../../http/client/index.js");
 var import_types = require("../../http/types.js");
+var import_inject = require("../../injector/inject.js");
+var import_injector = require("../../injector/injector.js");
+var import_interfaces = require("../../injector/interfaces.js");
 var import_schema = require("../../schema/index.js");
 var import_server_sent_events = require("../../sse/server-sent-events.js");
 var import_array = require("../../utils/array/array.js");
@@ -46,12 +48,12 @@ function compileClient(definition, options = {}) {
       [httpClientSymbol];
       [apiDefinitionSymbol];
       constructor(httpClientOrOptions) {
-        this[httpClientSymbol] = httpClientOrOptions instanceof import_client.HttpClient ? httpClientOrOptions : import_container.container.resolve(import_client.HttpClient, httpClientOrOptions);
+        this[httpClientSymbol] = httpClientOrOptions instanceof import_client.HttpClient ? httpClientOrOptions : (0, import_inject.inject)(import_client.HttpClient, httpClientOrOptions);
         this[apiDefinitionSymbol] = definition;
       }
     }
   }[apiName];
-  import_container.container.registerSingleton(api, {
+  import_injector.Injector.registerSingleton(api, {
     useFactory: (argument, context) => {
       const httpClient = argument instanceof import_client.HttpClient ? argument : context.resolve(import_client.HttpClient, argument ?? options.defaultHttpClientOptions);
       return new api(httpClient);

package/api/server/api-controller.d.ts

@@ -1,9 +1,9 @@
-import type { InjectableOptionsWithoutLifecycle } from '../../container/index.js';
+import type { InjectableOptionsWithoutLifecycle } from '../../injector/decorators.js';
 import type { Constructor, Type } from '../../types.js';
 import type { ApiController, ApiDefinition } from '../types.js';
 type ApiDefinitionProvider = () => ApiDefinition;
 export declare const apiControllerDefinition: unique symbol;
-export declare function getApiControllerDefinition(controller: Type): ApiDefinition;
+export declare function getApiControllerDefinition(controller: Type | ApiController): ApiDefinition;
 export declare function isApiController(controller: Type): boolean;
 export declare function ensureApiController(controller: Type): void;
 export declare function apiController<T = Type<ApiController>, A = any>(definition: ApiDefinition | ApiDefinitionProvider, injectableOptions?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;

package/api/server/api-controller.js

@@ -26,14 +26,15 @@ __export(api_controller_exports, {
   isApiController: () => isApiController
 });
 module.exports = __toCommonJS(api_controller_exports);
-var import_container = require("../../container/index.js");
+var import_decorators = require("../../injector/decorators.js");
 var import_object = require("../../utils/object/object.js");
 var import_type_guards = require("../../utils/type-guards.js");
 const apiControllerDefinition = Symbol("ApiController definition");
 const registeredApiControllers = /* @__PURE__ */ new Map();
 function getApiControllerDefinition(controller) {
-  ensureApiController(controller);
-  const definitionOrProvider = registeredApiControllers.get(controller);
+  const controllerType = (0, import_type_guards.isFunction)(controller) ? controller : controller.constructor;
+  ensureApiController(controllerType);
+  const definitionOrProvider = registeredApiControllers.get(controllerType);
   if ((0, import_type_guards.isFunction)(definitionOrProvider)) {
     return definitionOrProvider();
   }
@@ -50,7 +51,7 @@ function ensureApiController(controller) {
 function apiController(definition, injectableOptions = {}) {
   function apiControllerDecorator(constructor) {
     registeredApiControllers.set(constructor, definition);
-    (0, import_container.singleton)(injectableOptions)(constructor);
+    (0, import_decorators.Singleton)(injectableOptions)(constructor);
   }
   return apiControllerDecorator;
 }

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

@@ -22,7 +22,7 @@ __export(api_request_token_provider_exports, {
   NoopApiRequestTokenProvider: () => NoopApiRequestTokenProvider
 });
 module.exports = __toCommonJS(api_request_token_provider_exports);
-var import_container = require("../../container/index.js");
+var import_decorators = require("../../injector/decorators.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")
@@ -41,5 +41,5 @@ let NoopApiRequestTokenProvider = class NoopApiRequestTokenProvider2 extends Api
   }
 };
 NoopApiRequestTokenProvider = __decorate([
-  (0, import_container.singleton)({ alias: ApiRequestTokenProvider })
+  (0, import_decorators.Singleton)({ alias: ApiRequestTokenProvider })
 ], NoopApiRequestTokenProvider);

package/api/server/gateway.d.ts

@@ -1,9 +1,9 @@
 import 'urlpattern-polyfill';
-import type { Injectable } from '../../container/index.js';
-import { resolveArgumentType } from '../../container/index.js';
 import type { HttpServerRequestContext } from '../../http/server/http-server.js';
 import type { HttpServerRequest } from '../../http/server/index.js';
 import { HttpServerResponse } from '../../http/server/index.js';
+import type { Resolvable } from '../../injector/index.js';
+import { resolveArgumentType } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import type { Type } from '../../types.js';
 import type { AsyncMiddleware, AsyncMiddlewareNext } from '../../utils/middleware.js';
@@ -18,7 +18,7 @@ export type ApiGatewayMiddlewareContext = {
 };
 export type ApiGatewayMiddlewareNext = AsyncMiddlewareNext<HttpServerRequest, HttpServerResponse>;
 export type ApiGatewayMiddleware = AsyncMiddleware<HttpServerRequest, HttpServerResponse, ApiGatewayMiddlewareContext>;
-export type ApiGatewayOptions = {
+export declare abstract class ApiGatewayOptions {
     /**
      * Api prefix. Pass `null` to disable prefix.
      * @default api
@@ -35,7 +35,7 @@ export type ApiGatewayOptions = {
      * @default 10 MB
      */
     defaultMaxBytes?: number;
-};
+}
 export type GatewayEndpoint = {
     definition: ApiEndpointDefinition;
     implementation: ApiEndpointServerImplementation;
@@ -55,7 +55,7 @@ export type ApiMetadata = {
  * router for {@link ApiTransport} requests to {@link ApiImplementation}
  * @todo error handling (standardized format, serialization etc.)
  */
-export declare class ApiGateway implements Injectable<ApiGatewayOptions> {
+export declare class ApiGateway implements Resolvable<ApiGatewayOptions> {
     private readonly requestTokenProvider;
     private readonly logger;
     private readonly prefix;
@@ -69,7 +69,6 @@ export declare class ApiGateway implements Injectable<ApiGatewayOptions> {
     constructor(requestTokenProvider: ApiRequestTokenProvider, logger: Logger, options?: ApiGatewayOptions);
     addMiddleware(middleware: ApiGatewayMiddleware): void;
     supressErrors(...errorTypes: Type<Error>[]): void;
-    registerApiController(controller: Type): Promise<void>;
     registerApi<T extends ApiDefinition>(definition: ApiDefinition, implementation: ApiController<T>): void;
     handleHttpServerRequestContext({ request, respond, close }: HttpServerRequestContext): Promise<void>;
     getApiMetadata(resource: URL): ApiMetadata;

package/api/server/gateway.js

@@ -18,15 +18,16 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var gateway_exports = {};
 __export(gateway_exports, {
-  ApiGateway: () => ApiGateway
+  ApiGateway: () => ApiGateway,
+  ApiGatewayOptions: () => ApiGatewayOptions
 });
 module.exports = __toCommonJS(gateway_exports);
 var import_urlpattern_polyfill = require("urlpattern-polyfill");
-var import_container = require("../../container/index.js");
 var import_bad_request_error = require("../../error/bad-request.error.js");
 var import_not_found_error = require("../../error/not-found.error.js");
 var import_not_implemented_error = require("../../error/not-implemented.error.js");
 var import_server = require("../../http/server/index.js");
+var import_injector = require("../../injector/index.js");
 var import_logger = require("../../logger/index.js");
 var import_schema = require("../../schema/index.js");
 var import_server_sent_events_source = require("../../sse/server-sent-events-source.js");
@@ -37,7 +38,6 @@ var import_type_guards = require("../../utils/type-guards.js");
 var import_units = require("../../utils/units.js");
 var import_types = require("../types.js");
 var import_utils = require("../utils.js");
-var import_api_controller = require("./api-controller.js");
 var import_api_request_token_provider = require("./api-request-token.provider.js");
 var import_error_handler = require("./error-handler.js");
 var import_middlewares = require("./middlewares/index.js");
@@ -62,6 +62,24 @@ var __param = function(paramIndex, decorator) {
   };
 };
 const defaultMaxBytes = 10 * import_units.mebibyte;
+class ApiGatewayOptions {
+  /**
+   * Api prefix. Pass `null` to disable prefix.
+   * @default api
+   */
+  prefix;
+  /** Initial middlewares */
+  middlewares;
+  /** Errors to supress in log output */
+  supressedErrors;
+  /** Cors middleware options */
+  cors;
+  /**
+   * Maximum size of request body. Useful to prevent harmful requests.
+   * @default 10 MB
+   */
+  defaultMaxBytes;
+}
 let ApiGateway = class ApiGateway2 {
   requestTokenProvider;
   logger;
@@ -92,11 +110,6 @@ let ApiGateway = class ApiGateway2 {
       this.supressedErrors.add(type);
     }
   }
-  async registerApiController(controller) {
-    const definition = (0, import_api_controller.getApiControllerDefinition)(controller);
-    const instance = await import_container.container.resolveAsync(controller);
-    this.registerApi(definition, instance);
-  }
   registerApi(definition, implementation) {
     for (const [name, endpointDefinition] of (0, import_types.normalizedApiDefinitionEndpointsEntries)(definition.endpoints)) {
       const versionArray = (0, import_type_guards.isUndefined)(endpointDefinition.version) ? [1] : (0, import_array.toArray)(endpointDefinition.version);
@@ -221,10 +234,10 @@ let ApiGateway = class ApiGateway2 {
   }
 };
 ApiGateway = __decorate([
-  (0, import_container.singleton)({
+  (0, import_injector.Singleton)({
     defaultArgumentProvider: (context) => context.resolve(import_tokens.API_MODULE_OPTIONS).gatewayOptions
   }),
-  __param(1, (0, import_container.resolveArg)("ApiGateway")),
-  __param(2, (0, import_container.injectArg)()),
-  __metadata("design:paramtypes", [import_api_request_token_provider.ApiRequestTokenProvider, import_logger.Logger, Object])
+  __param(1, (0, import_injector.ResolveArg)("ApiGateway")),
+  __param(2, (0, import_injector.InjectArg)()),
+  __metadata("design:paramtypes", [import_api_request_token_provider.ApiRequestTokenProvider, import_logger.Logger, ApiGatewayOptions])
 ], ApiGateway);

package/api/server/module.js

@@ -22,7 +22,7 @@ __export(module_exports, {
   configureApiServer: () => configureApiServer
 });
 module.exports = __toCommonJS(module_exports);
-var import_container = require("../../container/index.js");
+var import_injector = require("../../injector/injector.js");
 var import_type_guards = require("../../utils/type-guards.js");
 var import_api_controller = require("./api-controller.js");
 var import_api_request_token_provider = require("./api-request-token.provider.js");
@@ -34,12 +34,12 @@ function configureApiServer(options) {
   if ((0, import_type_guards.isDefined)(options.controllers)) {
     for (const controller of options.controllers) {
       (0, import_api_controller.ensureApiController)(controller);
+      import_injector.Injector.register(import_tokens.API_CONTROLLER, { useToken: controller }, { multi: true });
     }
-    apiModuleOptions.controllers = options.controllers;
   }
   if ((0, import_type_guards.isDefined)(options.requestTokenProvider)) {
-    import_container.container.registerSingleton(import_api_request_token_provider.ApiRequestTokenProvider, { useToken: options.requestTokenProvider });
+    import_injector.Injector.register(import_api_request_token_provider.ApiRequestTokenProvider, { useToken: options.requestTokenProvider });
   }
   apiModuleOptions.gatewayOptions = options.gatewayOptions ?? apiModuleOptions.gatewayOptions;
-  import_container.container.register(import_tokens.API_MODULE_OPTIONS, { useValue: apiModuleOptions });
+  import_injector.Injector.register(import_tokens.API_MODULE_OPTIONS, { useValue: apiModuleOptions });
 }

package/api/server/tokens.d.ts

@@ -1,2 +1,5 @@
+import type { ApiController } from '../types.js';
 import type { ApiModuleOptions } from './module.js';
-export declare const API_MODULE_OPTIONS: import("../../container/index.js").InjectionToken<ApiModuleOptions, any>;
+export declare const API_MODULE_OPTIONS: import("../../injector/token.js").InjectionToken<ApiModuleOptions, never>;
+export declare const API_CONTROLLER: import("../../injector/token.js").InjectionToken<ApiController, never>;
+export declare const API_CONTROLLERS: import("../../injector/token.js").InjectionToken<ApiController[], never>;

package/api/server/tokens.js

@@ -18,8 +18,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var tokens_exports = {};
 __export(tokens_exports, {
+  API_CONTROLLER: () => API_CONTROLLER,
+  API_CONTROLLERS: () => API_CONTROLLERS,
   API_MODULE_OPTIONS: () => API_MODULE_OPTIONS
 });
 module.exports = __toCommonJS(tokens_exports);
-var import_container = require("../../container/index.js");
-const API_MODULE_OPTIONS = (0, import_container.injectionToken)("ApiModuleOptions");
+var import_injector = require("../../injector/injector.js");
+var import_token = require("../../injector/token.js");
+const API_MODULE_OPTIONS = (0, import_token.injectionToken)("ApiModuleOptions");
+const API_CONTROLLER = (0, import_token.injectionToken)("ApiController");
+const API_CONTROLLERS = (0, import_token.injectionToken)("ApiControllers");
+import_injector.Injector.register(API_CONTROLLERS, { useToken: API_CONTROLLER, resolveAll: true });

package/application/application.d.ts

@@ -1,27 +1,30 @@
-import { Logger } from '../logger/index.js';
+import type { Resolvable } from '../injector/interfaces.js';
+import { resolveArgumentType } from '../injector/interfaces.js';
+import type { LoggerArgument } from '../logger/index.js';
 import type { Module } from '../module/module.js';
 import type { FunctionModuleFunction } from '../module/modules/function.module.js';
 import type { OneOrMany, Type } from '../types.js';
 import type { ReadonlyCancellationToken } from '../utils/cancellation-token.js';
-export declare class Application {
-    private static _instance;
+export type BootstrapFn = () => void | Promise<void>;
+export type RunOptions = {
+    bootstrap?: BootstrapFn;
+};
+export declare class Application implements Resolvable<LoggerArgument> {
+    #private;
+    static _instance: Application | undefined;
     private static get instance();
-    private readonly logger;
-    private readonly moduleTypesAndInstances;
-    private readonly shutdownPromise;
-    private readonly _shutdownToken;
+    readonly [resolveArgumentType]: string;
     get shutdownToken(): ReadonlyCancellationToken;
     static get shutdownToken(): ReadonlyCancellationToken;
-    constructor(logger: Logger);
     static registerModule(moduleType: Type<Module>): void;
     static registerModuleFunction(fn: FunctionModuleFunction): void;
-    static run(...functionsAndModules: OneOrMany<FunctionModuleFunction | Type<Module>>[]): void;
+    static run(...functionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;
     static waitForShutdown(): Promise<void>;
     static shutdown(): Promise<void>;
     static requestShutdown(): void;
     registerModule(moduleType: Module | Type<Module>): void;
     registerModuleFunction(fn: FunctionModuleFunction): void;
-    run(...functionsAndModules: OneOrMany<FunctionModuleFunction | Type<Module>>[]): void;
+    run(...optionsFunctionsAndModules: [RunOptions | OneOrMany<FunctionModuleFunction | Type<Module>>, ...OneOrMany<FunctionModuleFunction | Type<Module>>[]]): void;
     shutdown(): Promise<void>;
     requestShutdown(): void;
     waitForShutdown(): Promise<void>;