@tstdl/base 0.93.36 → 0.93.37

package/source/api/types.ts

@@ -1,195 +0,0 @@
-import type { Observable } from 'rxjs';
-
-import type { Auditor } from '#/audit/index.js';
-import type { Token } from '#/authentication/index.js';
-import type { HttpServerRequest, HttpServerResponse } from '#/http/server/index.js';
-import type { HttpMethod } from '#/http/types.js';
-import type { SchemaOutput, SchemaTestable } from '#/schema/index.js';
-import type { DataStream } from '#/sse/index.js';
-import type { ServerSentEventsSource } from '#/sse/server-sent-events-source.js';
-import type { ServerSentEvents } from '#/sse/server-sent-events.js';
-import type { NonUndefinable, OneOrMany, Record, ReturnTypeOrT } from '#/types/index.js';
-import { objectEntries } from '#/utils/object/object.js';
-import { isFunction } from '#/utils/type-guards.js';
-import { resolveValueOrProvider, type ValueOrProvider } from '#/utils/value-or-provider.js';
-import type { ApiGatewayMiddlewareContext } from './server/index.js';
-
-export type ApiRegistrationOptions = {
-  name?: string,
-  prefix?: string,
-};
-
-export type ApiRegistration = {
-  target: object,
-  name: string,
-  path: string,
-  prefix: string,
-};
-
-export type EndpointRegistrationOptions = {
-  path?: string,
-  description?: string,
-};
-
-export type ApiEndpointMethod = HttpMethod;
-
-export type ApiEndpointDefinitionParameters = SchemaTestable;
-export type ApiEndpointDefinitionBody = SchemaTestable | typeof String | typeof Uint8Array | typeof Blob | typeof ReadableStream;
-export type ApiEndpointDefinitionResult = SchemaTestable | typeof String | typeof Uint8Array | typeof Blob | typeof ReadableStream;
-
-export type ApiEndpointDataProvider<T> = T | ((request: HttpServerRequest, context: ApiGatewayMiddlewareContext) => T | Promise<T>);
-
-export type ApiEndpointDefinitionCors = {
-  accessControlAllowCredentials?: ApiEndpointDataProvider<boolean | undefined>,
-  accessControlAllowHeaders?: ApiEndpointDataProvider<OneOrMany<string> | undefined>,
-  accessControlAllowMethods?: ApiEndpointDataProvider<OneOrMany<HttpMethod> | undefined>,
-  accessControlAllowOrigin?: ApiEndpointDataProvider<string | undefined>,
-  autoAccessControlAllowOrigin?: ApiEndpointDataProvider<OneOrMany<string> | undefined>,
-  accessControlExposeHeaders?: ApiEndpointDataProvider<OneOrMany<string> | undefined>,
-  accessControlMaxAge?: ApiEndpointDataProvider<number | undefined>,
-};
-
-export type ApiEndpointDefinition = {
-  /**
-   * Http Method
-   * @default GET
-   */
-  method?: OneOrMany<ApiEndpointMethod>,
-
-  /** Endpoint prefix. Overwrites default from api and gateway. */
-  prefix?: string | null,
-
-  /** Root resource path. Overwrites default from {@link ApiDefinition}. */
-  rootResource?: string | null,
-
-  /**
-   * Sub resource in api
-   *
-   * results in
-   * ```ts
-   * ${endpoint.rootResource ?? api.ressource}/${endpoint.resource}
-   * ```
-   * @default name of endpoint property
-   */
-  resource?: string,
-
-  version?: OneOrMany<number | null>,
-  parameters?: ApiEndpointDefinitionParameters,
-  body?: ApiEndpointDefinitionBody,
-  result?: ApiEndpointDefinitionResult,
-
-  /** Maximum size of request body. Useful to prevent harmful requests. */
-  maxBytes?: number,
-  description?: string,
-  data?: Record,
-
-  /**
-   * If true, sets browsers fetch to { credentials: 'include' } and enables 'Access-Control-Allow-Credentials' header.
-   *
-   * @default false
-   */
-  credentials?: boolean,
-
-  cors?: ApiEndpointDefinitionCors,
-};
-
-export type ApiEndpointsDefinition = Record<string, ValueOrProvider<ApiEndpointDefinition>>;
-
-export type ApiDefinition<Resource extends string = string, Endpoints extends ApiEndpointsDefinition = ApiEndpointsDefinition> = {
-  /**
-   * Default root resource for endpoints.
-   */
-  resource: Resource,
-
-  /**
-   * Endpoint prefix. Overwrites default from gateway.
-   */
-  prefix?: string | null,
-
-  endpoints: Endpoints,
-};
-
-export type ApiEndpointKeys<T extends ApiDefinition> = Extract<keyof T['endpoints'], string>;
-export type NormalizedApiEndpoints<T extends ApiDefinition['endpoints']> = { [P in keyof T]: ReturnTypeOrT<T[P]> };
-export type ApiEndpoint<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NormalizedApiEndpoints<T['endpoints']>[K];
-
-export type ApiEndpointParametersSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['parameters']>;
-export type ApiEndpointBodySchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['body']>;
-export type ApiEndpointResultSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['result']>;
-
-export type ApiBinaryType = typeof Uint8Array | typeof Blob | typeof ReadableStream;
-
-export type ApiInputType<T extends SchemaTestable> =
-  | T extends ApiBinaryType ? InstanceType<Exclude<ApiBinaryType, typeof ReadableStream> | typeof ReadableStream<Uint8Array<ArrayBuffer>>>
-  : T extends typeof ServerSentEvents ? ServerSentEventsSource
-  : T extends typeof DataStream<infer U> ? AsyncIterable<U>
-  : T extends SchemaTestable ? SchemaOutput<T> : never;
-
-export type ApiOutputType<T extends SchemaTestable> =
-  | T extends typeof ReadableStream ? ReadableStream<Uint8Array<ArrayBuffer>>
-  : T extends typeof DataStream<infer U> ? Observable<U>
-  : T extends SchemaTestable ? SchemaOutput<T> : never;
-
-export type ApiParameters<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointParametersSchema<T, K>>;
-
-export type ApiClientBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointBodySchema<T, K>>;
-
-export type ApiServerBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiOutputType<ApiEndpointBodySchema<T, K>>;
-
-export type ApiServerResult<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointResultSchema<T, K>> | HttpServerResponse;
-
-export type ApiClientResult<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiOutputType<ApiEndpointResultSchema<T, K>>;
-
-export type ApiRequestData<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = {
-  parameters: ApiParameters<T, K>,
-  body: ApiServerBody<T, K>,
-  request: HttpServerRequest,
-};
-
-export type ApiRequestContext<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> = ApiRequestData<T, K> & {
-  tryGetToken<T extends Token>(): Promise<T | null>,
-  getToken<T extends Token>(): Promise<T>,
-  getAuditor(): Promise<Auditor>,
-};
-
-export type ApiEndpointServerImplementation<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> =
-  (context: ApiRequestContext<T, K>) => ApiServerResult<T, K> | Promise<ApiServerResult<T, K>>;
-
-export type ApiEndpointClientImplementation<T extends ApiDefinition = ApiDefinition, K extends ApiEndpointKeys<T> = ApiEndpointKeys<T>> =
-  ApiClientBody<T, K> extends never
-  ? ApiParameters<T, K> extends never
-  ? () => Promise<ApiClientResult<T, K>>
-  : (parameters: ApiParameters<T, K>) => Promise<ApiClientResult<T, K>>
-  : (parameters: ApiParameters<T, K> extends never ? undefined | Record<never, never> : ApiParameters<T, K>, body: ApiClientBody<T, K>) => Promise<ApiClientResult<T, K>>;
-
-export type ApiController<T extends ApiDefinition = any> = {
-  [P in ApiEndpointKeys<T>]: ApiEndpointServerImplementation<T, P>
-};
-
-export type ApiClientImplementation<T extends ApiDefinition = any> =
-  { [P in ApiEndpointKeys<T>]: ApiEndpointClientImplementation<T, P> }
-  & {
-    getEndpointResource<E extends ApiEndpointKeys<T>>(endpoint: E, parameters?: ApiParameters<T, E>): string,
-    getEndpointUrl<E extends ApiEndpointKeys<T>>(endpoint: E, parameters?: ApiParameters<T, E>): string,
-  };
-
-export function defineApi<T extends ApiDefinition>(definition: T): T {
-  return definition;
-}
-
-export async function resolveApiEndpointDataProvider<T>(request: HttpServerRequest, context: ApiGatewayMiddlewareContext, provider: ApiEndpointDataProvider<T>): Promise<T> {
-  if (isFunction(provider)) {
-    return await provider(request, context);
-  }
-
-  return provider;
-}
-
-export function normalizedApiDefinitionEndpoints<T extends ApiDefinition['endpoints']>(apiDefinitionEndpoints: T): NormalizedApiEndpoints<T> {
-  const entries = normalizedApiDefinitionEndpointsEntries(apiDefinitionEndpoints);
-  return Object.fromEntries(entries) as NormalizedApiEndpoints<T>;
-}
-
-export function normalizedApiDefinitionEndpointsEntries<T extends ApiDefinition['endpoints']>(apiDefinition: T): [keyof T, ApiEndpointDefinition][] {
-  return objectEntries(apiDefinition).map(([key, def]): [string, ApiEndpointDefinition] => [key as string, resolveValueOrProvider(def)]);
-}

package/source/api/utils.ts

@@ -1,27 +0,0 @@
-import { toArray } from '#/utils/array/array.js';
-import { compareByValueDescending } from '#/utils/comparison.js';
-import { sort } from '#/utils/iterable-helpers/sort.js';
-import { isDefined, isNull } from '#/utils/type-guards.js';
-import type { ApiDefinition, ApiEndpointDefinition } from './types.js';
-
-type GetApiEndpointUrlData = {
-  api: ApiDefinition,
-  endpoint: ApiEndpointDefinition,
-  defaultPrefix: string | undefined | null,
-  explicitVersion?: number | null,
-};
-
-export const defaultAccessControlAllowHeaders = 'Content-Type, Authorization';
-
-export function getFullApiEndpointResource({ api, endpoint, defaultPrefix, explicitVersion }: GetApiEndpointUrlData): string {
-  const versionArray = toArray(isDefined(explicitVersion) ? explicitVersion : endpoint.version);
-  const version = sort(versionArray, compareByValueDescending)[0];
-  const versionPrefix = isNull(version) ? undefined : `v${version ?? 1}`;
-  const rootResource = (isNull(endpoint.rootResource) ? '' : endpoint.rootResource) ?? api.resource;
-  const prefix = (isNull(endpoint.prefix) ? '' : endpoint.prefix) ?? (isNull(api.prefix) ? '' : api.prefix) ?? (isNull(defaultPrefix) ? undefined : (defaultPrefix ?? 'api'));
-
-  const parts = [prefix, versionPrefix, rootResource, endpoint.resource];
-  const path = parts.filter(isDefined).filter((part) => part.length > 0).join('/');
-
-  return `/${path}`;
-}

package/source/application/README.md

@@ -1,234 +0,0 @@
-# Application Module
-
-Provides a simple and structured way to bootstrap, run, and gracefully shut down applications and their modules.
-
-## Table of Contents
-
-- [Features](#features)
-- [Core Concepts](#core-concepts)
-  - [The Application Class](#the-application-class)
-  - [Providers](#providers)
-  - [Modules](#modules)
-  - [Lifecycle Hooks (Initializers & Destructors)](#lifecycle-hooks-initializers--destructors)
-  - [Graceful Shutdown](#graceful-shutdown)
-- [Usage](#usage)
-  - [Basic Application Setup](#basic-application-setup)
-  - [Creating a Custom Module](#creating-a-custom-module)
-  - [Using Initializers and Destructors](#using-initializers-and-destructors)
-  - [Managing Shutdown Programmatically](#managing-shutdown-programmatically)
-- [API Summary](#api-summary)
-  - [Application Class](#application-class-1)
-  - [Provider Functions](#provider-functions)
-
-## Features
-
-- **Modular Architecture**: Structure your application into independent, reusable modules.
-- **Lifecycle Management**: Handles starting and stopping modules in a controlled manner.
-- **Graceful Shutdown**: Responds to process signals (like `SIGINT`) to ensure clean application termination.
-- **Dependency Injection**: Seamlessly integrated with the `@tstdl/base/injector` for resolving modules and their dependencies.
-- **Lifecycle Hooks**: Run setup logic (e.g., database connections, configuration) before modules start, and cleanup logic after they stop.
-- **Asynchronous Operations**: Fully supports `async`/`await` for modern asynchronous workflows.
-
-## Core Concepts
-
-### The Application Class
-
-The `Application` class is the singleton that orchestrates the entire lifecycle of your application. You interact with it through its static `run()` method to configure and start the application. It manages a dedicated dependency injection container, ensuring modules and services are instantiated correctly.
-
-### Providers
-
-Configuration of the application is done through provider functions. These functions return configuration objects (`ProvidersItem`) that are passed to `Application.run()` in an array.
-
-#### built-in Providers
-
--   `provideModules()`: Registers the modules that the application will manage and run.
--   `provideInitializer()`: Registers setup functions that run before any modules are started.
--   `provideDestructor()`: Registers cleanup functions that run after all modules have stopped.
--   `provideSignalHandler()`: Sets up standard listeners for process signals (like `SIGINT`) to trigger a graceful shutdown.
-
-### Modules
-
-A module is a self-contained unit of functionality, defined either by a class that extends `Module` from `@tstdl/base/module` or a simple async function. Each module contains its main logic. The `Application` ensures that each registered module is executed. When a shutdown is initiated, it calls the `stop()` method on each class-based module, allowing for cleanup operations.
-
-### Lifecycle Hooks (Initializers & Destructors)
-
--   **Initializers**: These are functions that run before any modules are started. They are ideal for one-time setup tasks like configuring services, running database migrations, or connecting to external resources. They are registered using `provideInitializer`.
--   **Destructors**: These functions run after all modules have been stopped, just before the application exits. They are perfect for cleanup tasks like closing database connections. They are registered using `provideDestructor`.
-
-Both initializers and destructors are executed within the application's dependency injection context, so they can resolve and use any registered services.
-
-### Graceful Shutdown
-
-The application, when configured with `provideSignalHandler()`, automatically listens for process shutdown signals (e.g., `SIGINT` from Ctrl+C). When a signal is received, it initiates a graceful shutdown sequence:
-1.  A `CancellationSignal` is triggered, which is available via injection to all running modules. Modules should use this signal to break out of long-running loops.
-2.  The `stop()` method of each running class-based module is called.
-3.  The application waits for all modules to stop.
-4.  Registered destructors are executed.
-5.  The application exits.
-
-A shutdown can also be initiated programmatically by injecting the `Application` instance and calling its `requestShutdown()` or `shutdown()` methods.
-
-## Usage
-
-### Basic Application Setup
-
-Create an entry file (e.g., `main.ts`) and use `Application.run()` with a set of providers. The simplest module is just a function.
-
-```typescript
-// main.ts
-import { Application, provideModules, provideSignalHandler } from '@tstdl/base/application';
-import { inject } from '@tstdl/base/injector';
-import { Logger } from '@tstdl/base/logger';
-
-// A simple function can act as a module.
-async function main(): Promise<void> {
-  const logger = inject(Logger);
-  const app = inject(Application);
-
-  logger.info('Application is running!');
-  app.shutdownSignal.subscribe(() => logger.info('Shutting down...'));
-}
-
-// Pass the application name and an array of providers to run().
-Application.run('MyApp', [
-  provideModules(main),
-  provideSignalHandler(), // Handles Ctrl+C for graceful shutdown
-]);
-```
-
-### Creating a Custom Module
-
-For more complex, stateful logic, create a class that extends `Module`.
-
-```typescript
-// services/background-worker.module.ts
-import { CancellationSignal } from '@tstdl/base/cancellation';
-import { inject, Singleton } from '@tstdl/base/injector';
-import { Logger } from '@tstdl/base/logger';
-import { Module } from '@tstdl/base/module';
-import { cancelableTimeout } from '@tstdl/base/utils';
-
-@Singleton()
-export class BackgroundWorkerModule extends Module {
-  readonly #logger = inject(Logger, BackgroundWorkerModule.name);
-
-  constructor() {
-    super('BackgroundWorker');
-  }
-
-  protected override async _run(cancellationSignal: CancellationSignal): Promise<void> {
-    this.#logger.info('Background worker started.');
-
-    while (cancellationSignal.isUnset) {
-      this.#logger.info('Processing a task...');
-      // Do some work...
-
-      const result = await cancelableTimeout(5000, cancellationSignal);
-
-      if (result == 'canceled') {
-        break; // Exit the loop if a shutdown is requested
-      }
-    }
-
-    this.#logger.info('Background worker shutting down.');
-  }
-}
-
-// main.ts
-import { Application, provideModules, provideSignalHandler } from '@tstdl/base/application';
-import { BackgroundWorkerModule } from './services/background-worker.module.js';
-
-Application.run('MyWorkerApp', [
-  provideModules(BackgroundWorkerModule),
-  provideSignalHandler(),
-]);
-```
-
-### Using Initializers and Destructors
-
-Use `provideInitializer` for setup and `provideDestructor` for cleanup.
-
-```typescript
-// main.ts
-import { Application, provideInitializer, provideDestructor, provideModules, provideSignalHandler } from '@tstdl/base/application';
-import { inject } from '@tstdl/base/injector';
-import { DatabaseService } from './my-database.service'; // Example service
-
-// An initializer function for setup tasks.
-async function initializeDatabase(): Promise<void> {
-  // Initializers can use dependency injection.
-  const databaseService = await inject.async(DatabaseService);
-  console.log('Connecting to database...');
-  await databaseService.connect();
-  console.log('Database connected.');
-}
-
-// A destructor function for cleanup tasks.
-async function disconnectDatabase(): Promise<void> {
-  const databaseService = await inject.async(DatabaseService);
-  console.log('Disconnecting from database...');
-  await databaseService.disconnect();
-  console.log('Database disconnected.');
-}
-
-Application.run('MyApp', [
-  provideInitializer(initializeDatabase),
-  provideModules(/* your modules here */),
-  provideDestructor(disconnectDatabase),
-  provideSignalHandler(),
-]);
-```
-
-### Managing Shutdown Programmatically
-
-You can trigger a shutdown from within your application by injecting the `Application` instance.
-
-```typescript
-// main.ts
-import { Application, provideModules, provideSignalHandler } from '@tstdl/base/application';
-import { inject } from '@tstdl/base/injector';
-import { timeout } from '@tstdl/base/utils';
-
-// A module that shuts down the application after its task is complete.
-async function criticalTask(): Promise<void> {
-  const app = inject(Application);
-  console.log('Starting critical task...');
-  await timeout(2000); // Simulate work
-  console.log('Critical task finished. Shutting down application.');
-
-  // Option 1: Request a non-blocking shutdown.
-  app.requestShutdown();
-
-  // Option 2: Request shutdown and wait for it to complete.
-  // await app.shutdown();
-  // console.log('Application has been shut down.');
-}
-
-Application.run('CriticalTaskApp', [
-  provideModules(criticalTask),
-  provideSignalHandler(),
-]);
-```
-
-## API Summary
-
-### Application Class
-
-| Method/Property     | Parameters                                       | Returns         | Description                                                                                  |
-| ------------------- | ------------------------------------------------ | --------------- | -------------------------------------------------------------------------------------------- |
-| `static create()`   | `name: string`, `providers: ProvidersItem[][]`   | `Application`   | Creates an `Application` instance with its own DI container. Does not start it.              |
-| `static run()`      | `name: string`, `providers: ProvidersItem[][]`   | `Application`   | Creates and runs an `Application` instance.                                                  |
-| `shutdownSignal`    | -                                                | `CancellationSignal` | A signal that is set when a shutdown is initiated.                                           |
-| `requestShutdown()` | -                                                | `void`          | Signals the application to start a graceful shutdown without waiting for it to complete.   |
-| `shutdown()`        | -                                                | `Promise<void>` | Requests a shutdown and returns a promise that resolves when the application has fully stopped. |
-| `waitForShutdown()` | -                                                | `Promise<void>` | Returns a promise that resolves when the application has fully shut down.                      |
-
-### Provider Functions
-
-| Function                | Parameters                                           | Returns           | Description                                                                              |
-| ----------------------- | ---------------------------------------------------- | ----------------- | ---------------------------------------------------------------------------------------- |
-| `provideModules()`      | `...modules: (Function \| Type<Module>)[]`           | `ProvidersItem[]` | Registers modules or functions to be run by the application.                             |
-| `provideInitializer()`  | `fn: () => void \| Promise<void>`                    | `ProvidersItem`   | Registers a function to run before any modules are started.                              |
-| `provideDestructor()`   | `fn: () => void \| Promise<void>`                    | `ProvidersItem`   | Registers a function to run after all modules have stopped.                              |
-| `provideSignalHandler()`| -                                                    | `ProvidersItem`   | Registers a default signal handler for graceful shutdown on `SIGINT`, `SIGTERM`, etc.     |
-| `provideShutdownSignal()`| `signal: CancellationSignal`                         | `ProvidersItem`   | Provides an external `CancellationSignal` to control the application's lifecycle.      |

package/source/application/application.ts

@@ -1,173 +0,0 @@
-import { CancellationSignal, CancellationToken } from '#/cancellation/token.js';
-import { Singleton } from '#/injector/decorators.js';
-import { inject, injectAll, runInInjectionContext } from '#/injector/inject.js';
-import { Injector, type ProvidersItem } from '#/injector/injector.js';
-import { injectionToken } from '#/injector/token.js';
-import { Logger } from '#/logger/index.js';
-import { Module, ModuleState } from '#/module/index.js';
-import { DeferredPromise } from '#/promise/deferred-promise.js';
-import type { OneOrMany, Type } from '#/types/index.js';
-import { mapAsync } from '#/utils/async-iterable-helpers/map.js';
-import { toArrayAsync } from '#/utils/async-iterable-helpers/to-array.js';
-import { isDefined, isFunction } from '#/utils/type-guards.js';
-
-export type InitializerFn = () => void | Promise<void>;
-export type DestructorFn = () => void | Promise<void>;
-
-export const APPLICATION_MODULE = injectionToken<Module>('ApplicationModule');
-export const APPLICATION_INITIALIZER = injectionToken<InitializerFn>('ApplicationInitializer');
-export const APPLICATION_DESTRUCTOR = injectionToken<DestructorFn>('ApplicationDestructor');
-export const APPLICATION_INSTANCE_ID = injectionToken<string>('ApplicationInstanceId');
-export const APPLICATION_NAME = injectionToken<string>('ApplicationName');
-
-@Singleton()
-export class Application {
-  readonly #name = inject(APPLICATION_NAME);
-  readonly #injector = inject(Injector);
-  readonly #logger = inject(Logger, this.#name);
-  readonly #moduleTypesAndInstances = new Set<Module | Type<Module>>(injectAll(APPLICATION_MODULE, undefined, { optional: true }));
-  readonly #shutdownPromise = new DeferredPromise();
-  readonly #shutdownToken = inject(CancellationSignal, undefined, { optional: true })?.createChild() ?? new CancellationToken();
-
-  static create(name: string, providers: OneOrMany<ProvidersItem>[] = []): Application {
-    const injector = new Injector(`${name}ApplicationInjector`);
-
-    injector.register(APPLICATION_INSTANCE_ID, { useValue: crypto.randomUUID() });
-    injector.register(APPLICATION_NAME, { useValue: name });
-
-    for (const providersItem of providers.flat()) {
-      injector.register(providersItem.provide, providersItem, { multi: providersItem.multi });
-    }
-
-    return injector.resolve(Application);
-  }
-
-  static run(name: string, providers: OneOrMany<ProvidersItem>[] = []): Application {
-    const app = Application.create(name, providers);
-    app.run();
-
-    return app;
-  }
-
-  get shutdownSignal(): CancellationSignal {
-    return this.#shutdownToken.signal;
-  }
-
-  registerModule(moduleType: Module | Type<Module>): void {
-    this.#moduleTypesAndInstances.add(moduleType);
-  }
-
-  run(): void {
-    if (this.#shutdownToken.isSet) {
-      throw new Error('Application was shut down.');
-    }
-
-    void this._run();
-  }
-
-  async runAndWait(): Promise<void> {
-    this.run();
-    await this.waitForShutdown();
-  }
-
-  async shutdown(): Promise<void> {
-    this.requestShutdown();
-    await this.#shutdownPromise;
-  }
-
-  requestShutdown(): void {
-    if (this.shutdownSignal.isSet) {
-      return;
-    }
-
-    this.#shutdownToken.set();
-  }
-
-  async waitForShutdown(): Promise<void> {
-    await this.#shutdownPromise;
-  }
-
-  private async _run(): Promise<void> {
-    let modules: Module[] | undefined;
-
-    try {
-      const initializers = await this.#injector.resolveAllAsync(APPLICATION_INITIALIZER, undefined, { optional: true });
-
-      for (const initializer of initializers) {
-        await runInInjectionContext(this.#injector, initializer);
-      }
-
-      modules = await toArrayAsync(mapAsync(this.#moduleTypesAndInstances, async (instanceOrType) => (isFunction(instanceOrType) ? await this.#injector.resolveAsync(instanceOrType) : instanceOrType)));
-
-      await Promise.race([
-        this.runModules(modules),
-        this.shutdownSignal,
-      ]);
-    }
-    catch (error) {
-      this.#logger.error(error as Error, { includeRest: true, includeStack: true });
-    }
-    finally {
-      this.requestShutdown();
-
-      this.#logger.info('Shutting down');
-
-      if (isDefined(modules)) {
-        await this.stopModules(modules);
-      }
-
-      const destructors = await this.#injector.resolveAllAsync(APPLICATION_DESTRUCTOR, undefined, { optional: true });
-
-      for (const destructor of destructors) {
-        try {
-          await runInInjectionContext(this.#injector, destructor);
-        }
-        catch (error) {
-          this.#logger.error(error as Error, { message: 'An error occurred during application destruction.' });
-        }
-      }
-
-      await this.#injector.dispose();
-
-      this.#logger.info('Bye');
-    }
-
-    this.#shutdownPromise.resolve();
-  }
-
-  private async runModules(modules: Module[]): Promise<void> {
-    const promises = modules.map(async (module) => {
-      try {
-        this.#logger.info(`Starting module ${module.name}.`);
-        await runInInjectionContext(this.#injector, async () => await module.run());
-        this.#logger.info(`Module ${module.name} stopped.`);
-      }
-      catch (error) {
-        this.#logger.error(error as Error);
-        this.requestShutdown();
-      }
-    });
-
-    await Promise.all(promises);
-  }
-
-  private async stopModules(modules: Module[]): Promise<void> {
-    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 as Error);
-        this.requestShutdown();
-      }
-    });
-
-    await Promise.all(promises);
-  }
-}

package/source/application/index.ts

@@ -1,2 +0,0 @@
-export * from './application.js';
-export * from './providers.js';