@depup/nestjs__common 11.1.16-depup.1

package/interfaces/middleware/middleware-config-proxy.interface.js

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

package/interfaces/middleware/middleware-configuration.interface.d.ts

@@ -0,0 +1,12 @@
+import { RequestMethod } from '../../enums';
+import { Type } from '../type.interface';
+import { VersionValue } from '../version-options.interface';
+export interface RouteInfo {
+    path: string;
+    method: RequestMethod;
+    version?: VersionValue;
+}
+export interface MiddlewareConfiguration<T = any> {
+    middleware: T;
+    forRoutes: (Type<any> | string | RouteInfo)[];
+}

package/interfaces/middleware/middleware-configuration.interface.js

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

package/interfaces/middleware/middleware-consumer.interface.d.ts

@@ -0,0 +1,18 @@
+import { Type } from '../type.interface';
+import { MiddlewareConfigProxy } from './middleware-config-proxy.interface';
+/**
+ * Interface defining method for applying user defined middleware to routes.
+ *
+ * @see [MiddlewareConsumer](https://docs.nestjs.com/middleware#middleware-consumer)
+ *
+ * @publicApi
+ */
+export interface MiddlewareConsumer {
+    /**
+     * @param {...(Type | Function)} middleware middleware class/function or array of classes/functions
+     * to be attached to the passed routes.
+     *
+     * @returns {MiddlewareConfigProxy}
+     */
+    apply(...middleware: (Type<any> | Function)[]): MiddlewareConfigProxy;
+}

package/interfaces/middleware/middleware-consumer.interface.js

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

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

@@ -0,0 +1,8 @@
+/**
+ * @see [Middleware](https://docs.nestjs.com/middleware)
+ *
+ * @publicApi
+ */
+export interface NestMiddleware<TRequest = any, TResponse = any> {
+    use(req: TRequest, res: TResponse, next: (error?: any) => void): any;
+}

package/interfaces/middleware/nest-middleware.interface.js

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

package/interfaces/modules/dynamic-module.interface.d.ts

@@ -0,0 +1,25 @@
+import { Type } from '../type.interface';
+import { ModuleMetadata } from './module-metadata.interface';
+/**
+ * Interface defining a Dynamic Module.
+ *
+ * @see [Dynamic Modules](https://docs.nestjs.com/modules#dynamic-modules)
+ *
+ * @publicApi
+ */
+export interface DynamicModule extends ModuleMetadata {
+    /**
+     * A module reference
+     */
+    module: Type<any>;
+    /**
+     * When "true", makes a module global-scoped.
+     *
+     * Once imported into any module, a global-scoped module will be visible
+     * in all modules. Thereafter, modules that wish to inject a service exported
+     * from a global module do not need to import the provider module.
+     *
+     * @default false
+     */
+    global?: boolean;
+}

package/interfaces/modules/dynamic-module.interface.js

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

package/interfaces/modules/forward-reference.interface.d.ts

@@ -0,0 +1,3 @@
+export interface ForwardReference<T = any> {
+    forwardRef: T;
+}

package/interfaces/modules/forward-reference.interface.js

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

package/interfaces/modules/index.d.ts

@@ -0,0 +1,8 @@
+export * from './dynamic-module.interface';
+export * from './forward-reference.interface';
+export * from './injection-token.interface';
+export * from './introspection-result.interface';
+export * from './module-metadata.interface';
+export * from './nest-module.interface';
+export * from './optional-factory-dependency.interface';
+export * from './provider.interface';

package/interfaces/modules/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./dynamic-module.interface"), exports);
+tslib_1.__exportStar(require("./forward-reference.interface"), exports);
+tslib_1.__exportStar(require("./injection-token.interface"), exports);
+tslib_1.__exportStar(require("./introspection-result.interface"), exports);
+tslib_1.__exportStar(require("./module-metadata.interface"), exports);
+tslib_1.__exportStar(require("./nest-module.interface"), exports);
+tslib_1.__exportStar(require("./optional-factory-dependency.interface"), exports);
+tslib_1.__exportStar(require("./provider.interface"), exports);

package/interfaces/modules/injection-token.interface.d.ts

@@ -0,0 +1,6 @@
+import { Abstract } from '../abstract.interface';
+import { Type } from '../type.interface';
+/**
+ * @publicApi
+ */
+export type InjectionToken<T = any> = string | symbol | Type<T> | Abstract<T> | Function;

package/interfaces/modules/injection-token.interface.js

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

package/interfaces/modules/introspection-result.interface.d.ts

@@ -0,0 +1,10 @@
+import { Scope } from '../scope-options.interface';
+/**
+ * @publicApi
+ */
+export interface IntrospectionResult {
+    /**
+     * Enum defining lifetime of host class or factory.
+     */
+    scope: Scope;
+}

package/interfaces/modules/introspection-result.interface.js

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

package/interfaces/modules/module-metadata.interface.d.ts

@@ -0,0 +1,34 @@
+import { Abstract } from '../abstract.interface';
+import { Type } from '../type.interface';
+import { DynamicModule } from './dynamic-module.interface';
+import { ForwardReference } from './forward-reference.interface';
+import { Provider } from './provider.interface';
+/**
+ * Interface defining the property object that describes the module.
+ *
+ * @see [Modules](https://docs.nestjs.com/modules)
+ *
+ * @publicApi
+ */
+export interface ModuleMetadata {
+    /**
+     * Optional list of imported modules that export the providers which are
+     * required in this module.
+     */
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    /**
+     * Optional list of controllers defined in this module which have to be
+     * instantiated.
+     */
+    controllers?: Type<any>[];
+    /**
+     * Optional list of providers that will be instantiated by the Nest injector
+     * and that may be shared at least across this module.
+     */
+    providers?: Provider[];
+    /**
+     * Optional list of the subset of providers that are provided by this module
+     * and should be available in other modules which import this module.
+     */
+    exports?: Array<DynamicModule | string | symbol | Provider | ForwardReference | Abstract<any> | Function>;
+}

package/interfaces/modules/module-metadata.interface.js

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

package/interfaces/modules/nest-module.interface.d.ts

@@ -0,0 +1,7 @@
+import { MiddlewareConsumer } from '../middleware/middleware-consumer.interface';
+/**
+ * @publicApi
+ */
+export interface NestModule {
+    configure(consumer: MiddlewareConsumer): any;
+}

package/interfaces/modules/nest-module.interface.js

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

package/interfaces/modules/optional-factory-dependency.interface.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from './injection-token.interface';
+/**
+ * @publicApi
+ */
+export type OptionalFactoryDependency = {
+    token: InjectionToken;
+    optional: boolean;
+};

package/interfaces/modules/optional-factory-dependency.interface.js

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

package/interfaces/modules/provider.interface.d.ts

@@ -0,0 +1,156 @@
+import { Scope } from '../scope-options.interface';
+import { Type } from '../type.interface';
+import { InjectionToken } from './injection-token.interface';
+import { OptionalFactoryDependency } from './optional-factory-dependency.interface';
+/**
+ *
+ * @publicApi
+ */
+export type Provider<T = any> = Type<any> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+/**
+ * Interface defining a *Class* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const configServiceProvider = {
+ * provide: ConfigService,
+ * useClass:
+ *   process.env.NODE_ENV === 'development'
+ *     ? DevelopmentConfigService
+ *     : ProductionConfigService,
+ * };
+ * ```
+ *
+ * @see [Class providers](https://docs.nestjs.com/fundamentals/custom-providers#class-providers-useclass)
+ * @see [Injection scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+export interface ClassProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Type (class name) of provider (instance to be injected).
+     */
+    useClass: Type<T>;
+    /**
+     * Optional enum defining lifetime of the provider that is injected.
+     */
+    scope?: Scope;
+    /**
+     * This option is only available on factory providers!
+     *
+     * @see [Use factory](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory)
+     */
+    inject?: never;
+    /**
+     * 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;
+}
+/**
+ * Interface defining a *Value* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const connectionProvider = {
+ *   provide: 'CONNECTION',
+ *   useValue: connection,
+ * };
+ * ```
+ *
+ * @see [Value providers](https://docs.nestjs.com/fundamentals/custom-providers#value-providers-usevalue)
+ *
+ * @publicApi
+ */
+export interface ValueProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Instance of a provider to be injected.
+     */
+    useValue: T;
+    /**
+     * This option is only available on factory providers!
+     *
+     * @see [Use factory](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory)
+     */
+    inject?: never;
+}
+/**
+ * Interface defining a *Factory* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const connectionFactory = {
+ *   provide: 'CONNECTION',
+ *   useFactory: (optionsProvider: OptionsProvider) => {
+ *     const options = optionsProvider.get();
+ *     return new DatabaseConnection(options);
+ *   },
+ *   inject: [OptionsProvider],
+ * };
+ * ```
+ *
+ * @see [Factory providers](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory)
+ * @see [Injection scopes](https://docs.nestjs.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+export interface FactoryProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Factory function that returns an instance of the provider to be injected.
+     */
+    useFactory: (...args: any[]) => T | Promise<T>;
+    /**
+     * Optional list of providers to be injected into the context of the Factory function.
+     */
+    inject?: Array<InjectionToken | OptionalFactoryDependency>;
+    /**
+     * Optional enum defining lifetime of the provider that is returned by the Factory function.
+     */
+    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;
+}
+/**
+ * Interface defining an *Existing* (aliased) type provider.
+ *
+ * For example:
+ * ```typescript
+ * const loggerAliasProvider = {
+ *   provide: 'AliasedLoggerService',
+ *   useExisting: LoggerService
+ * };
+ * ```
+ *
+ * @see [Alias providers](https://docs.nestjs.com/fundamentals/custom-providers#alias-providers-useexisting)
+ *
+ * @publicApi
+ */
+export interface ExistingProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Provider to be aliased by the Injection token.
+     */
+    useExisting: any;
+}

package/interfaces/modules/provider.interface.js

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

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

@@ -0,0 +1,68 @@
+import { LoggerService, LogLevel } from '../services/logger.service';
+/**
+ * @publicApi
+ */
+export declare class NestApplicationContextOptions {
+    /**
+     * Specifies the logger to use.  Pass `false` to turn off logging.
+     */
+    logger?: LoggerService | LogLevel[] | false;
+    /**
+     * Whether to abort the process on Error. By default, the process is exited.
+     * Pass `false` to override the default behavior. If `false` is passed, Nest will not exit
+     * the application and instead will rethrow the exception.
+     * @default true
+     */
+    abortOnError?: boolean | undefined;
+    /**
+     * If enabled, logs will be buffered until the "Logger#flush" method is called.
+     * @default false
+     */
+    bufferLogs?: boolean;
+    /**
+     * If enabled, logs will be automatically flushed and buffer detached when
+     * application initialization process either completes or fails.
+     * @default true
+     */
+    autoFlushLogs?: boolean;
+    /**
+     * Whether to run application in the preview mode.
+     * In the preview mode, providers/controllers are not instantiated & resolved.
+     *
+     * @default false
+     */
+    preview?: boolean;
+    /**
+     * Whether to generate a serialized graph snapshot.
+     *
+     * @default false
+     */
+    snapshot?: boolean;
+    /**
+     * Determines what algorithm use to generate module ids.
+     * When set to `deep-hash`, the module id is generated based on the serialized module definition.
+     * When set to `reference`, each module obtains a unique id based on its reference.
+     *
+     * @default 'reference'
+     */
+    moduleIdGeneratorAlgorithm?: 'deep-hash' | 'reference';
+    /**
+     * Instrument the application context.
+     * This option allows you to add custom instrumentation to the application context.
+     */
+    instrument?: {
+        /**
+         * Function that decorates each instance created by the application context.
+         * This function can be used to add custom properties or methods to the instance.
+         * @param instance The instance to decorate.
+         * @returns The decorated instance.
+         */
+        instanceDecorator: (instance: unknown) => unknown;
+    };
+    /**
+     * If enabled, will force the use of console.log/console.error instead of process.stdout/stderr.write
+     * in the default ConsoleLogger. This is useful for test environments like Jest that can buffer console calls.
+     * @default false
+     */
+    forceConsole?: boolean;
+}

package/interfaces/nest-application-context-options.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestApplicationContextOptions = void 0;
+/**
+ * @publicApi
+ */
+class NestApplicationContextOptions {
+}
+exports.NestApplicationContextOptions = NestApplicationContextOptions;

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

@@ -0,0 +1,139 @@
+import { ShutdownSignal } from '../enums/shutdown-signal.enum';
+import { LoggerService, LogLevel } from '../services/logger.service';
+import { DynamicModule } from './modules';
+import { NestApplicationContextOptions } from './nest-application-context-options.interface';
+import { ShutdownHooksOptions } from './shutdown-hooks-options.interface';
+import { Type } from './type.interface';
+export type SelectOptions = Pick<NestApplicationContextOptions, 'abortOnError'>;
+export interface GetOrResolveOptions {
+    /**
+     * If enabled, lookup will only be performed in the host module.
+     * @default false
+     */
+    strict?: boolean;
+    /**
+     * If enabled, instead of returning a first instance registered under a given token,
+     * a list of instances will be returned.
+     * @default false
+     */
+    each?: boolean;
+}
+/**
+ * Interface defining NestApplicationContext.
+ *
+ * @publicApi
+ */
+export interface INestApplicationContext {
+    /**
+     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
+     * @returns {INestApplicationContext}
+     */
+    select<T>(module: Type<T> | DynamicModule, options?: SelectOptions): INestApplicationContext;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): TResult;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): TResult;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult | Array<TResult>}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: GetOrResolveOptions): TResult | Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each: true;
+    }): Promise<Array<TResult>>;
+    /**
+     * Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {Promise<TResult | Array<TResult>>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: GetOrResolveOptions): Promise<TResult | Array<TResult>>;
+    /**
+     * Registers the request/context object for a given context ID (DI container sub-tree).
+     * @returns {void}
+     */
+    registerRequestByContextId<T = any>(request: T, contextId: {
+        id: number;
+    }): void;
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+    /**
+     * Sets custom logger service.
+     * Flushes buffered logs if auto flush is on.
+     * @returns {void}
+     */
+    useLogger(logger: LoggerService | LogLevel[] | false): void;
+    /**
+     * Prints buffered logs and detaches buffer.
+     * @returns {void}
+     */
+    flushLogs(): void;
+    /**
+     * Enables the usage of shutdown hooks. Will call the
+     * `onApplicationShutdown` function of a provider if the
+     * process receives a shutdown signal.
+     *
+     * @param {ShutdownSignal[] | string[]} [signals] The system signals to listen to
+     * @param {ShutdownHooksOptions} [options] Options for configuring shutdown hooks behavior
+     *
+     * @returns {this} The Nest application context instance
+     */
+    enableShutdownHooks(signals?: ShutdownSignal[] | string[], options?: ShutdownHooksOptions): this;
+    /**
+     * Initializes the Nest application.
+     * Calls the Nest lifecycle events.
+     * It isn't mandatory to call this method directly.
+     *
+     * @returns {Promise<this>} The NestApplicationContext instance as Promise
+     */
+    init(): Promise<this>;
+}

package/interfaces/nest-application-context.interface.js

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

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

@@ -0,0 +1,29 @@
+import { CorsOptions, CorsOptionsDelegate } from './external/cors-options.interface';
+import { HttpsOptions } from './external/https-options.interface';
+import { NestApplicationContextOptions } from './nest-application-context-options.interface';
+/**
+ * @publicApi
+ */
+export interface NestApplicationOptions extends NestApplicationContextOptions {
+    /**
+     * CORS options from [CORS package](https://github.com/expressjs/cors#configuration-options)
+     */
+    cors?: boolean | CorsOptions | CorsOptionsDelegate<any>;
+    /**
+     * Whether to use underlying platform body parser.
+     */
+    bodyParser?: boolean;
+    /**
+     * Set of configurable HTTPS options
+     */
+    httpsOptions?: HttpsOptions;
+    /**
+     * Whether to register the raw request body on the request. Use `req.rawBody`.
+     */
+    rawBody?: boolean;
+    /**
+     * Force close open HTTP connections. Useful if restarting your application hangs due to
+     * keep-alive connections in the HTTP adapter.
+     */
+    forceCloseConnections?: boolean;
+}

package/interfaces/nest-application-options.interface.js

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