@depup/nestjs__common 11.1.16-depup.1

package/interfaces/nest-application.interface.d.ts

@@ -0,0 +1,135 @@
+import { CanActivate } from './features/can-activate.interface';
+import { NestInterceptor } from './features/nest-interceptor.interface';
+import { GlobalPrefixOptions } from './global-prefix-options.interface';
+import { HttpServer } from './http/http-server.interface';
+import { ExceptionFilter, INestMicroservice, NestHybridApplicationOptions, PipeTransform } from './index';
+import { INestApplicationContext } from './nest-application-context.interface';
+import { VersioningOptions } from './version-options.interface';
+import { WebSocketAdapter } from './websockets/web-socket-adapter.interface';
+/**
+ * Interface defining the core NestApplication object.
+ *
+ * @publicApi
+ */
+export interface INestApplication<TServer = any> extends INestApplicationContext {
+    /**
+     * A wrapper function around HTTP adapter method: `adapter.use()`.
+     * Example `app.use(cors())`
+     *
+     * @returns {this}
+     */
+    use(...args: any[]): this;
+    /**
+     * Enables CORS (Cross-Origin Resource Sharing)
+     *
+     * @returns {void}
+     */
+    enableCors(options?: any): void;
+    /**
+     * Enables Versioning for the application.
+     * By default, URI-based versioning is used.
+     *
+     * @param {VersioningOptions} options
+     * @returns {this}
+     */
+    enableVersioning(options?: VersioningOptions): this;
+    /**
+     * Starts the application.
+     *
+     * @param {number|string} port
+     * @param {string} [hostname]
+     * @param {Function} [callback] Optional callback
+     * @returns {Promise} A Promise that, when resolved, is a reference to the underlying HttpServer.
+     */
+    listen(port: number | string, callback?: () => void): Promise<any>;
+    listen(port: number | string, hostname: string, callback?: () => void): Promise<any>;
+    /**
+     * Returns the url the application is listening at, based on OS and IP version. Returns as an IP value either in IPv6 or IPv4
+     *
+     * @returns {Promise<string>} The IP where the server is listening
+     */
+    getUrl(): Promise<string>;
+    /**
+     * Registers a prefix for every HTTP route path.
+     *
+     * @param {string} prefix The prefix for every HTTP route path (for example `/v1/api`)
+     * @param {GlobalPrefixOptions} options Global prefix options object
+     * @returns {this}
+     */
+    setGlobalPrefix(prefix: string, options?: GlobalPrefixOptions): this;
+    /**
+     * Register Ws Adapter which will be used inside Gateways.
+     * Use when you want to override default `socket.io` library.
+     *
+     * @param {WebSocketAdapter} adapter
+     * @returns {this}
+     */
+    useWebSocketAdapter(adapter: WebSocketAdapter): this;
+    /**
+     * Connects microservice to the NestApplication instance. Transforms application
+     * to a hybrid instance.
+     *
+     * @template {object} T
+     * @param {T} options Microservice options object
+     * @param {NestHybridApplicationOptions} hybridOptions Hybrid options object
+     * @returns {INestMicroservice}
+     */
+    connectMicroservice<T extends object = any>(options: T, hybridOptions?: NestHybridApplicationOptions): INestMicroservice;
+    /**
+     * Returns array of the microservices connected to the NestApplication.
+     *
+     * @returns {INestMicroservice[]}
+     */
+    getMicroservices(): INestMicroservice[];
+    /**
+     * Returns the underlying native HTTP server.
+     *
+     * @returns {TServer}
+     */
+    getHttpServer(): TServer;
+    /**
+     * Returns the underlying HTTP adapter.
+     *
+     * @returns {HttpServer}
+     */
+    getHttpAdapter(): HttpServer;
+    /**
+     * Starts all connected microservices asynchronously.
+     *
+     * @returns {Promise}
+     */
+    startAllMicroservices(): Promise<this>;
+    /**
+     * Registers exception filters as global filters (will be used within
+     * every HTTP route handler)
+     *
+     * @param {...ExceptionFilter} filters
+     */
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    /**
+     * Registers pipes as global pipes (will be used within every HTTP route handler)
+     *
+     * @param {...PipeTransform} pipes
+     */
+    useGlobalPipes(...pipes: PipeTransform<any>[]): this;
+    /**
+     * Registers interceptors as global interceptors (will be used within
+     * every HTTP route handler)
+     *
+     * @param {...NestInterceptor} interceptors
+     */
+    useGlobalInterceptors(...interceptors: NestInterceptor[]): this;
+    /**
+     * Registers guards as global guards (will be used within every HTTP route handler)
+     *
+     * @param {...CanActivate} guards
+     */
+    useGlobalGuards(...guards: CanActivate[]): this;
+    /**
+     * Terminates the application (including NestApplication, Gateways, and each connected
+     * microservice)
+     *
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+}

package/interfaces/nest-application.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/nest-microservice.interface.d.ts

@@ -0,0 +1,75 @@
+import { Observable } from 'rxjs';
+import { ExceptionFilter } from './exceptions/exception-filter.interface';
+import { CanActivate } from './features/can-activate.interface';
+import { NestInterceptor } from './features/nest-interceptor.interface';
+import { PipeTransform } from './features/pipe-transform.interface';
+import { INestApplicationContext } from './nest-application-context.interface';
+import { WebSocketAdapter } from './websockets/web-socket-adapter.interface';
+/**
+ * Interface describing Microservice Context.
+ *
+ * @publicApi
+ */
+export interface INestMicroservice extends INestApplicationContext {
+    /**
+     * Starts the microservice.
+     *
+     * @returns {void}
+     */
+    listen(): Promise<any>;
+    /**
+     * Registers a web socket adapter that will be used for Gateways.
+     * Use to override the default `socket.io` library.
+     *
+     * @param {WebSocketAdapter} adapter
+     * @returns {this}
+     */
+    useWebSocketAdapter(adapter: WebSocketAdapter): this;
+    /**
+     * Registers global exception filters (will be used for every pattern handler).
+     *
+     * @param {...ExceptionFilter} filters
+     */
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    /**
+     * Registers global pipes (will be used for every pattern handler).
+     *
+     * @param {...PipeTransform} pipes
+     */
+    useGlobalPipes(...pipes: PipeTransform<any>[]): this;
+    /**
+     * Registers global interceptors (will be used for every pattern handler).
+     *
+     * @param {...NestInterceptor} interceptors
+     */
+    useGlobalInterceptors(...interceptors: NestInterceptor[]): this;
+    /**
+     * Registers global guards (will be used for every pattern handler).
+     *
+     * @param {...CanActivate} guards
+     */
+    useGlobalGuards(...guards: CanActivate[]): this;
+    /**
+     * Terminates the application.
+     *
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+    /**
+     * Returns an observable that emits status changes.
+     *
+     * @returns {Observable<string>}
+     */
+    status: Observable<string>;
+    /**
+     * Registers an event listener for the given event.
+     * @param event Event name
+     * @param callback Callback to be executed when the event is emitted
+     */
+    on<EventsMap extends Record<string, Function> = Record<string, Function>, EventKey extends keyof EventsMap = keyof EventsMap, EventCallback extends EventsMap[EventKey] = EventsMap[EventKey]>(event: EventKey, callback: EventCallback): void;
+    /**
+     * Returns an instance of the underlying server/broker instance,
+     * or a group of servers if there are more than one.
+     */
+    unwrap<T>(): T;
+}

package/interfaces/nest-microservice.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/scope-options.interface.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @publicApi
+ */
+export declare enum Scope {
+    /**
+     * The provider can be shared across multiple classes. The provider lifetime
+     * is strictly tied to the application lifecycle. Once the application has
+     * bootstrapped, all providers have been instantiated.
+     */
+    DEFAULT = 0,
+    /**
+     * A new private instance of the provider is instantiated for every use
+     */
+    TRANSIENT = 1,
+    /**
+     * A new instance is instantiated for each request processing pipeline
+     */
+    REQUEST = 2
+}
+/**
+ * @publicApi
+ *
+ * @see [Injection Scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ */
+export interface ScopeOptions {
+    /**
+     * Specifies the lifetime of an injected Provider or Controller.
+     */
+    scope?: Scope;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}

package/interfaces/scope-options.interface.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+/**
+ * @publicApi
+ */
+var Scope;
+(function (Scope) {
+    /**
+     * The provider can be shared across multiple classes. The provider lifetime
+     * is strictly tied to the application lifecycle. Once the application has
+     * bootstrapped, all providers have been instantiated.
+     */
+    Scope[Scope["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * A new private instance of the provider is instantiated for every use
+     */
+    Scope[Scope["TRANSIENT"] = 1] = "TRANSIENT";
+    /**
+     * A new instance is instantiated for each request processing pipeline
+     */
+    Scope[Scope["REQUEST"] = 2] = "REQUEST";
+})(Scope || (exports.Scope = Scope = {}));

package/interfaces/shutdown-hooks-options.interface.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Options for configuring shutdown hooks behavior.
+ *
+ * @publicApi
+ */
+export interface ShutdownHooksOptions {
+    /**
+     * If true, uses `process.exit()` instead of `process.kill(process.pid, signal)`
+     * after shutdown hooks complete. This ensures the 'exit' event is properly
+     * triggered, which is required for async loggers (like Pino with transports)
+     * to flush their buffers before the process terminates.
+     *
+     * Note: Using `process.exit()` will:
+     * - Change the exit code (e.g., SIGTERM: 143 → 0)
+     * - May not trigger other signal handlers from third-party libraries
+     * - May affect orchestrator (Kubernetes, Docker) behavior
+     *
+     * @default false
+     */
+    useProcessExit?: boolean;
+}

package/interfaces/shutdown-hooks-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/type.interface.d.ts

@@ -0,0 +1,3 @@
+export interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}

package/interfaces/type.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/version-options.interface.d.ts

@@ -0,0 +1,92 @@
+import { VersioningType } from '../enums/version-type.enum';
+/**
+ * Indicates that this will work for any version passed in the request, or no version.
+ *
+ * @publicApi
+ */
+export declare const VERSION_NEUTRAL: unique symbol;
+/**
+ * @publicApi
+ */
+export type VersionValue = string | typeof VERSION_NEUTRAL | Array<string | typeof VERSION_NEUTRAL>;
+/**
+ * @publicApi
+ */
+export interface VersionOptions {
+    /**
+     * Specifies an optional API Version. When configured, methods
+     * within the controller will only be routed if the request version
+     * matches the specified value.
+     *
+     * Supported only by HTTP-based applications (does not apply to non-HTTP microservices).
+     *
+     * @see [Versioning](https://docs.nestjs.com/techniques/versioning)
+     */
+    version?: VersionValue;
+}
+/**
+ * @publicApi
+ */
+export interface HeaderVersioningOptions {
+    type: VersioningType.HEADER;
+    /**
+     * The name of the Request Header that contains the version.
+     */
+    header: string;
+}
+/**
+ * @publicApi
+ */
+export interface UriVersioningOptions {
+    type: VersioningType.URI;
+    /**
+     * Optional prefix that will prepend the version within the URI.
+     *
+     * Defaults to `v`.
+     *
+     * Ex. Assuming a version of `1`, for `/api/v1/route`, `v` is the prefix.
+     */
+    prefix?: string | false;
+}
+/**
+ * @publicApi
+ */
+export interface MediaTypeVersioningOptions {
+    type: VersioningType.MEDIA_TYPE;
+    /**
+     * The key within the Media Type Header to determine the version from.
+     *
+     * Ex. For `application/json;v=1`, the key is `v=`.
+     */
+    key: string;
+}
+/**
+ * @publicApi
+ */
+export interface CustomVersioningOptions {
+    type: VersioningType.CUSTOM;
+    /**
+     * A function that accepts a request object (specific to the underlying platform, ie Express or Fastify)
+     * and returns a single version value or an ordered array of versions, in order from HIGHEST to LOWEST.
+     *
+     * Ex. Returned version array = ['3.1', '3.0', '2.5', '2', '1.9']
+     *
+     * Use type assertion or narrowing to identify the specific request type.
+     */
+    extractor: (request: unknown) => string | string[];
+}
+/**
+ * @publicApi
+ */
+interface VersioningCommonOptions {
+    /**
+     * The default version to be used as a fallback when you did not provide some
+     * version to `@Controller()` nor `@Version()`.
+     */
+    defaultVersion?: VersionOptions['version'];
+}
+/**
+ * @publicApi
+ */
+export type VersioningOptions = VersioningCommonOptions & (HeaderVersioningOptions | UriVersioningOptions | MediaTypeVersioningOptions | CustomVersioningOptions);
+export {};

package/interfaces/version-options.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION_NEUTRAL = void 0;
+/**
+ * Indicates that this will work for any version passed in the request, or no version.
+ *
+ * @publicApi
+ */
+exports.VERSION_NEUTRAL = Symbol('VERSION_NEUTRAL');

package/interfaces/websockets/web-socket-adapter.interface.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+/**
+ * @publicApi
+ */
+export interface WsMessageHandler<T = string> {
+    message: T;
+    callback: (...args: any[]) => Observable<any> | Promise<any>;
+    isAckHandledManually: boolean;
+}
+/**
+ * @publicApi
+ */
+export interface WebSocketAdapter<TServer = any, TClient = any, TOptions = any> {
+    create(port: number, options?: TOptions): TServer;
+    bindClientConnect(server: TServer, callback: Function): any;
+    bindClientDisconnect?(client: TClient, callback: Function): any;
+    bindMessageHandlers(client: TClient, handlers: WsMessageHandler[], transform: (data: any) => Observable<any>): any;
+    close(server: TServer): any;
+}

package/interfaces/websockets/web-socket-adapter.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/module-utils/configurable-module.builder.d.ts

@@ -0,0 +1,93 @@
+import { DynamicModule } from '../interfaces';
+import { Logger } from '../services/logger.service';
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY, DEFAULT_METHOD_KEY } from './constants';
+import { ConfigurableModuleHost } from './interfaces';
+/**
+ * @publicApi
+ */
+export interface ConfigurableModuleBuilderOptions {
+    /**
+     * Specifies what injection token should be used for the module options provider.
+     * By default, an auto-generated UUID will be used.
+     */
+    optionsInjectionToken?: string | symbol;
+    /**
+     * By default, an UUID will be used as a module options provider token.
+     * Explicitly specifying the "moduleName" will instruct the "ConfigurableModuleBuilder"
+     * to use a more descriptive provider token.
+     *
+     * For example, `moduleName: "Cache"` will auto-generate the provider token: "CACHE_MODULE_OPTIONS".
+     */
+    moduleName?: string;
+    /**
+     * Indicates whether module should always be "transient" - meaning,
+     * every time you call the static method to construct a dynamic module,
+     * regardless of what arguments you pass in, a new "unique" module will be created.
+     *
+     * @default false
+     */
+    alwaysTransient?: boolean;
+}
+/**
+ * Factory that lets you create configurable modules and
+ * provides a way to reduce the majority of dynamic module boilerplate.
+ *
+ * @publicApi
+ */
+export declare class ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey extends string = typeof DEFAULT_METHOD_KEY, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY, ExtraModuleDefinitionOptions = {}> {
+    protected readonly options: ConfigurableModuleBuilderOptions;
+    protected staticMethodKey: StaticMethodKey;
+    protected factoryClassMethodKey: FactoryClassMethodKey;
+    protected extras: ExtraModuleDefinitionOptions;
+    protected transformModuleDefinition: (definition: DynamicModule, extraOptions: ExtraModuleDefinitionOptions) => DynamicModule;
+    protected readonly logger: Logger;
+    constructor(options?: ConfigurableModuleBuilderOptions, parentBuilder?: ConfigurableModuleBuilder<ModuleOptions>);
+    /**
+     * Registers the "extras" object (a set of extra options that can be used to modify the dynamic module definition).
+     * Values you specify within the "extras" object will be used as default values (that can be overridden by module consumers).
+     *
+     * This method also applies the so-called "module definition transform function" that takes the auto-generated
+     * dynamic module object ("DynamicModule") and the actual consumer "extras" object as input parameters.
+     * The "extras" object consists of values explicitly specified by module consumers and default values.
+     *
+     * @example
+     * ```typescript
+     * .setExtras<{ isGlobal?: boolean }>({ isGlobal: false }, (definition, extras) =>
+     *    ({ ...definition, global: extras.isGlobal })
+     * )
+     * ```
+     */
+    setExtras<ExtraModuleDefinitionOptions>(extras: ExtraModuleDefinitionOptions, transformDefinition?: (definition: DynamicModule, extras: ExtraModuleDefinitionOptions) => DynamicModule): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Dynamic modules must expose public static methods that let you pass in
+     * configuration parameters (control the module's behavior from the outside).
+     * Some frequently used names that you may have seen in other modules are:
+     * "forRoot", "forFeature", "register", "configure".
+     *
+     * This method "setClassMethodName" lets you specify the name of the
+     * method that will be auto-generated.
+     *
+     * @param key name of the method
+     */
+    setClassMethodName<StaticMethodKey extends string>(key: StaticMethodKey): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Asynchronously configured modules (that rely on other modules, i.e. "ConfigModule")
+     * let you pass the configuration factory class that will be registered and instantiated as a provider.
+     * This provider then will be used to retrieve the module's configuration. To provide the configuration,
+     * the corresponding factory method must be implemented.
+     *
+     * This method ("setFactoryMethodName") lets you control what method name will have to be
+     * implemented by the config factory (default is "create").
+     *
+     * @param key name of the method
+     */
+    setFactoryMethodName<FactoryClassMethodKey extends string>(key: FactoryClassMethodKey): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Returns an object consisting of multiple properties that lets you
+     * easily construct dynamic configurable modules. See "ConfigurableModuleHost" interface for more details.
+     */
+    build(): ConfigurableModuleHost<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    private constructInjectionTokenString;
+    private createConfigurableModuleCls;
+    private createTypeProxy;
+}