@depup/nestjs__core 11.1.17-depup.0

package/repl/repl-context.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplContext = void 0;
+const common_1 = require("@nestjs/common");
+const application_config_1 = require("../application-config");
+const injector_1 = require("../injector");
+const internal_core_module_1 = require("../injector/internal-core-module/internal-core-module");
+const native_functions_1 = require("./native-functions");
+class ReplContext {
+    constructor(app, nativeFunctionsClassRefs) {
+        this.app = app;
+        this.logger = new common_1.Logger(ReplContext.name);
+        this.debugRegistry = {};
+        this.globalScope = Object.create(null);
+        this.nativeFunctions = new Map();
+        this.container = app.container; // Using `any` because `app.container` is not public.
+        this.initializeContext();
+        this.initializeNativeFunctions(nativeFunctionsClassRefs || []);
+    }
+    writeToStdout(text) {
+        process.stdout.write(text);
+    }
+    initializeContext() {
+        const modules = this.container.getModules();
+        modules.forEach(moduleRef => {
+            let moduleName = moduleRef.metatype.name;
+            if (moduleName === internal_core_module_1.InternalCoreModule.name) {
+                return;
+            }
+            if (this.globalScope[moduleName]) {
+                moduleName += ` (${moduleRef.token})`;
+            }
+            this.introspectCollection(moduleRef, moduleName, 'providers');
+            this.introspectCollection(moduleRef, moduleName, 'controllers');
+            // For in REPL auto-complete functionality
+            Object.defineProperty(this.globalScope, moduleName, {
+                value: moduleRef.metatype,
+                configurable: false,
+                enumerable: true,
+            });
+        });
+    }
+    introspectCollection(moduleRef, moduleKey, collection) {
+        const moduleDebugEntry = {};
+        moduleRef[collection].forEach(({ token }) => {
+            const stringifiedToken = this.stringifyToken(token);
+            if (stringifiedToken === application_config_1.ApplicationConfig.name ||
+                stringifiedToken === moduleRef.metatype.name) {
+                return;
+            }
+            if (!this.globalScope[stringifiedToken]) {
+                // For in REPL auto-complete functionality
+                Object.defineProperty(this.globalScope, stringifiedToken, {
+                    value: token,
+                    configurable: false,
+                    enumerable: true,
+                });
+            }
+            if (stringifiedToken === injector_1.ModuleRef.name) {
+                return;
+            }
+            moduleDebugEntry[stringifiedToken] = token;
+        });
+        this.debugRegistry[moduleKey] = {
+            ...this.debugRegistry?.[moduleKey],
+            [collection]: moduleDebugEntry,
+        };
+    }
+    stringifyToken(token) {
+        return typeof token !== 'string'
+            ? typeof token === 'function'
+                ? token.name
+                : token?.toString()
+            : `"${token}"`;
+    }
+    addNativeFunction(NativeFunctionRef) {
+        const nativeFunction = new NativeFunctionRef(this);
+        const nativeFunctions = [nativeFunction];
+        this.nativeFunctions.set(nativeFunction.fnDefinition.name, nativeFunction);
+        nativeFunction.fnDefinition.aliases?.forEach(aliasName => {
+            const aliasNativeFunction = Object.create(nativeFunction);
+            aliasNativeFunction.fnDefinition = {
+                name: aliasName,
+                description: aliasNativeFunction.fnDefinition.description,
+                signature: aliasNativeFunction.fnDefinition.signature,
+            };
+            this.nativeFunctions.set(aliasName, aliasNativeFunction);
+            nativeFunctions.push(aliasNativeFunction);
+        });
+        return nativeFunctions;
+    }
+    registerFunctionIntoGlobalScope(nativeFunction) {
+        // Bind the method to REPL's context:
+        this.globalScope[nativeFunction.fnDefinition.name] =
+            nativeFunction.action.bind(nativeFunction);
+        // Load the help trigger as a `help` getter on each native function:
+        const functionBoundRef = this.globalScope[nativeFunction.fnDefinition.name];
+        Object.defineProperty(functionBoundRef, 'help', {
+            enumerable: false,
+            configurable: false,
+            get: () => 
+            // Dynamically builds the help message as will unlikely to be called
+            // several times.
+            this.writeToStdout(nativeFunction.makeHelpMessage()),
+        });
+    }
+    initializeNativeFunctions(nativeFunctionsClassRefs) {
+        const builtInFunctionsClassRefs = [
+            native_functions_1.HelpReplFn,
+            native_functions_1.GetReplFn,
+            native_functions_1.ResolveReplFn,
+            native_functions_1.SelectReplFn,
+            native_functions_1.DebugReplFn,
+            native_functions_1.MethodsReplFn,
+        ];
+        builtInFunctionsClassRefs
+            .concat(nativeFunctionsClassRefs)
+            .forEach(NativeFunction => {
+            const nativeFunctions = this.addNativeFunction(NativeFunction);
+            nativeFunctions.forEach(nativeFunction => {
+                this.registerFunctionIntoGlobalScope(nativeFunction);
+            });
+        });
+    }
+}
+exports.ReplContext = ReplContext;

package/repl/repl-function.d.ts

@@ -0,0 +1,18 @@
+import { Logger } from '@nestjs/common';
+import { ReplContext } from './repl-context';
+import type { ReplFnDefinition } from './repl.interfaces';
+export declare abstract class ReplFunction<ActionParams extends Array<unknown> = Array<unknown>, ActionReturn = any> {
+    protected readonly ctx: ReplContext;
+    /** Metadata that describes the built-in function itself. */
+    abstract fnDefinition: ReplFnDefinition;
+    protected readonly logger: Logger;
+    constructor(ctx: ReplContext);
+    /**
+     * Method called when the function is invoked from the REPL by the user.
+     */
+    abstract action(...args: ActionParams): ActionReturn;
+    /**
+     * @returns A message displayed by calling `<fnName>.help`
+     */
+    makeHelpMessage(): string;
+}

package/repl/repl-function.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplFunction = void 0;
+const cli_colors_util_1 = require("@nestjs/common/utils/cli-colors.util");
+class ReplFunction {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.logger = ctx.logger;
+    }
+    /**
+     * @returns A message displayed by calling `<fnName>.help`
+     */
+    makeHelpMessage() {
+        const { description, name, signature } = this.fnDefinition;
+        const fnSignatureWithName = `${name}${signature}`;
+        return `${cli_colors_util_1.clc.yellow(description)}\n${cli_colors_util_1.clc.magentaBright('Interface:')} ${cli_colors_util_1.clc.bold(fnSignatureWithName)}\n`;
+    }
+}
+exports.ReplFunction = ReplFunction;

package/repl/repl-logger.d.ts

@@ -0,0 +1,5 @@
+import { ConsoleLogger } from '@nestjs/common';
+export declare class ReplLogger extends ConsoleLogger {
+    private static readonly ignoredContexts;
+    log(_message: any, context?: string): void;
+}

package/repl/repl-logger.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplLogger = void 0;
+const common_1 = require("@nestjs/common");
+const nest_application_1 = require("../nest-application");
+const router_explorer_1 = require("../router/router-explorer");
+const routes_resolver_1 = require("../router/routes-resolver");
+class ReplLogger extends common_1.ConsoleLogger {
+    log(_message, context) {
+        if (ReplLogger.ignoredContexts.includes(context)) {
+            return;
+        }
+        // eslint-disable-next-line
+        return super.log.apply(this, Array.from(arguments));
+    }
+}
+exports.ReplLogger = ReplLogger;
+ReplLogger.ignoredContexts = [
+    routes_resolver_1.RoutesResolver.name,
+    router_explorer_1.RouterExplorer.name,
+    nest_application_1.NestApplication.name,
+];

package/repl/repl-native-commands.d.ts

@@ -0,0 +1,2 @@
+import type { REPLServer } from 'repl';
+export declare function defineDefaultCommandsOnRepl(replServer: REPLServer): void;

package/repl/repl-native-commands.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineDefaultCommandsOnRepl = defineDefaultCommandsOnRepl;
+/**
+ * Displays a list of available commands in the REPL alongside with their
+ * descriptions.
+ * (c) This code was inspired by the 'help' command from Node.js core:
+ * {@link https://github.com/nodejs/node/blob/58b60c1393dd65cd228a8b0084a19acd2c1d16aa/lib/repl.js#L1741-L1759}
+ */
+function listAllCommands(replServer) {
+    Object.keys(replServer.commands)
+        .sort()
+        .forEach(name => {
+        const cmd = replServer.commands[name];
+        if (cmd) {
+            replServer.output.write(`${name}\t${cmd.help || ''}\n`);
+        }
+    });
+}
+function defineDefaultCommandsOnRepl(replServer) {
+    replServer.defineCommand('help', {
+        help: 'Show REPL options',
+        action(name) {
+            this.clearBufferedCommand();
+            if (name) {
+                // Considering native commands before native nestjs injected functions.
+                const nativeCommandOrFunction = this.commands[name] || this.context[name];
+                // NOTE: If the command was retrieve from the context, it will have a `help`
+                // getter property that outputs the helper message and returns undefined.
+                // But if the command was retrieve from the `commands` object, it will
+                // have a `help` property that returns the helper message.
+                const helpMessage = nativeCommandOrFunction?.help;
+                if (helpMessage) {
+                    this.output.write(`${helpMessage}\n`);
+                }
+            }
+            else {
+                listAllCommands(this);
+                this.output.write('\n\n');
+                this.context.help();
+                this.output.write('\nPress Ctrl+C to abort current expression, Ctrl+D to exit the REPL\n');
+            }
+            this.displayPrompt();
+        },
+    });
+}

package/repl/repl.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModule, Type } from '@nestjs/common';
+import type { ReplOptions } from 'repl';
+export declare function repl(module: Type | DynamicModule, replOptions?: ReplOptions): Promise<import("node:repl").REPLServer>;

package/repl/repl.interfaces.d.ts

@@ -0,0 +1,16 @@
+import type { ReplContext } from './repl-context';
+import type { ReplFunction } from './repl-function';
+export type ReplFnDefinition = {
+    /** Function's name. Note that this should be a valid JavaScript function name. */
+    name: string;
+    /** Alternative names to the function. */
+    aliases?: ReplFnDefinition['name'][];
+    /** Function's description to display when `<function>.help` is entered. */
+    description: string;
+    /**
+     * Function's signature following TypeScript _function type expression_ syntax.
+     * @example '(token: InjectionToken) => any'
+     */
+    signature: string;
+};
+export type ReplFunctionClass = new (replContext: ReplContext) => ReplFunction;

package/repl/repl.interfaces.js

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

package/repl/repl.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repl = repl;
+const common_1 = require("@nestjs/common");
+const cli_colors_util_1 = require("@nestjs/common/utils/cli-colors.util");
+const nest_factory_1 = require("../nest-factory");
+const assign_to_object_util_1 = require("./assign-to-object.util");
+const constants_1 = require("./constants");
+const repl_context_1 = require("./repl-context");
+const repl_logger_1 = require("./repl-logger");
+const repl_native_commands_1 = require("./repl-native-commands");
+async function repl(module, replOptions = {}) {
+    const app = await nest_factory_1.NestFactory.createApplicationContext(module, {
+        abortOnError: false,
+        logger: new repl_logger_1.ReplLogger(),
+    });
+    await app.init();
+    const replContext = new repl_context_1.ReplContext(app);
+    common_1.Logger.log(constants_1.REPL_INITIALIZED_MESSAGE);
+    const _repl = await Promise.resolve().then(() => require('repl'));
+    const replServer = _repl.start({
+        prompt: cli_colors_util_1.clc.green('> '),
+        ignoreUndefined: true,
+        ...replOptions,
+    });
+    (0, assign_to_object_util_1.assignToObject)(replServer.context, replContext.globalScope);
+    (0, repl_native_commands_1.defineDefaultCommandsOnRepl)(replServer);
+    replServer.on('exit', async () => {
+        await app.close();
+    });
+    return replServer;
+}

package/router/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interfaces';
+export * from './request';
+export { RouterModule } from './router-module';

package/router/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterModule = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./interfaces"), exports);
+tslib_1.__exportStar(require("./request"), exports);
+var router_module_1 = require("./router-module");
+Object.defineProperty(exports, "RouterModule", { enumerable: true, get: function () { return router_module_1.RouterModule; } });

package/router/interfaces/exceptions-filter.interface.d.ts

@@ -0,0 +1,6 @@
+import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
+import { ExceptionsHandler } from '../../exceptions/exceptions-handler';
+import { ContextId } from '../../injector/instance-wrapper';
+export interface ExceptionsFilter {
+    create(instance: Controller, callback: Function, module: string, contextId?: ContextId, inquirerId?: string): ExceptionsHandler;
+}

package/router/interfaces/exceptions-filter.interface.js

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

package/router/interfaces/exclude-route-metadata.interface.d.ts

@@ -0,0 +1,15 @@
+import { RequestMethod } from '@nestjs/common';
+export interface ExcludeRouteMetadata {
+    /**
+     * Route path.
+     */
+    path: string;
+    /**
+     * Regular expression representing the route path.
+     */
+    pathRegex: RegExp;
+    /**
+     * HTTP request method (e.g., GET, POST).
+     */
+    requestMethod: RequestMethod;
+}

package/router/interfaces/exclude-route-metadata.interface.js

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

package/router/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './routes.interface';

package/router/interfaces/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./routes.interface"), exports);

package/router/interfaces/resolver.interface.d.ts

@@ -0,0 +1,5 @@
+export interface Resolver {
+    resolve(instance: any, basePath: string): void;
+    registerNotFoundHandler(): void;
+    registerExceptionHandler(): void;
+}

package/router/interfaces/resolver.interface.js

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

package/router/interfaces/route-params-factory.interface.d.ts

@@ -0,0 +1,8 @@
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
+export interface IRouteParamsFactory {
+    exchangeKeyForValue<TRequest extends Record<string, any> = any, TResponse = any, TResult = any>(key: RouteParamtypes | string, data: any, { req, res, next }: {
+        req: TRequest;
+        res: TResponse;
+        next: Function;
+    }): TResult | null;
+}

package/router/interfaces/route-params-factory.interface.js

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

package/router/interfaces/route-path-metadata.interface.d.ts

@@ -0,0 +1,32 @@
+import { VersioningOptions } from '@nestjs/common';
+import { VersionValue } from '@nestjs/common/interfaces';
+export interface RoutePathMetadata {
+    /**
+     * Controller-level path (e.g., @Controller('resource') = "resource").
+     */
+    ctrlPath?: string;
+    /**
+     * Method-level path (e.g., @Get('resource') = "resource").
+     */
+    methodPath?: string;
+    /**
+     * Global route prefix specified with the "NestApplication#setGlobalPrefix" method.
+     */
+    globalPrefix?: string;
+    /**
+     * Module-level path registered through the "RouterModule".
+     */
+    modulePath?: string;
+    /**
+     * Controller-level version (e.g., @Controller({ version: '1.0' }) = "1.0").
+     */
+    controllerVersion?: VersionValue;
+    /**
+     * Method-level version (e.g., @Version('1.0') = "1.0").
+     */
+    methodVersion?: VersionValue;
+    /**
+     * API versioning options object.
+     */
+    versioningOptions?: VersioningOptions;
+}

package/router/interfaces/route-path-metadata.interface.js

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

package/router/interfaces/routes.interface.d.ts

@@ -0,0 +1,7 @@
+import { Type } from '@nestjs/common';
+export interface RouteTree {
+    path: string;
+    module?: Type<any>;
+    children?: (RouteTree | Type<any>)[];
+}
+export type Routes = RouteTree[];

package/router/interfaces/routes.interface.js

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

package/router/legacy-route-converter.d.ts

@@ -0,0 +1,16 @@
+export declare class LegacyRouteConverter {
+    private static readonly logger;
+    /**
+     * Convert legacy routes to the new format (syntax).
+     * path-to-regexp used by Express>=v5 and @fastify/middie>=v9 no longer support unnamed wildcards.
+     * This method attempts to convert the old syntax to the new one, and logs an error if it fails.
+     * @param route The route to convert.
+     * @param options Options object.
+     * @returns The converted route, or the original route if it cannot be converted.
+     */
+    static tryConvert(route: string, options?: {
+        logs?: boolean;
+    }): string;
+    static printError(route: string): void;
+    static printWarning(route: string): void;
+}

package/router/legacy-route-converter.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyRouteConverter = void 0;
+const common_1 = require("@nestjs/common");
+const UNSUPPORTED_PATH_MESSAGE = (text, route) => `Unsupported route path: "${route}". In previous versions, the symbols ?, *, and + were used to denote optional or repeating path parameters. The latest version of "path-to-regexp" now requires the use of named parameters. For example, instead of using a route like /users/* to capture all routes starting with "/users", you should use /users/*path. For more details, refer to the migration guide.`;
+class LegacyRouteConverter {
+    /**
+     * Convert legacy routes to the new format (syntax).
+     * path-to-regexp used by Express>=v5 and @fastify/middie>=v9 no longer support unnamed wildcards.
+     * This method attempts to convert the old syntax to the new one, and logs an error if it fails.
+     * @param route The route to convert.
+     * @param options Options object.
+     * @returns The converted route, or the original route if it cannot be converted.
+     */
+    static tryConvert(route, options) {
+        // Normalize path to eliminate additional if statements.
+        const routeWithLeadingSlash = route.startsWith('/') ? route : `/${route}`;
+        const normalizedRoute = route.endsWith('/')
+            ? routeWithLeadingSlash
+            : `${routeWithLeadingSlash}/`;
+        const loggingEnabled = options?.logs ?? true;
+        const printWarning = loggingEnabled
+            ? this.printWarning.bind(this)
+            : () => { };
+        if (normalizedRoute.endsWith('/(.*)/')) {
+            // Skip printing warning for the "all" wildcard.
+            if (normalizedRoute !== '/(.*)/') {
+                printWarning(route);
+            }
+            return route.replace('(.*)', '{*path}');
+        }
+        if (normalizedRoute.endsWith('/*/')) {
+            // Skip printing warning for the "all" wildcard.
+            if (normalizedRoute !== '/*/') {
+                printWarning(route);
+            }
+            return route.replace('*', '{*path}');
+        }
+        if (normalizedRoute.endsWith('/+/')) {
+            printWarning(route);
+            return route.replace('/+', '/*path');
+        }
+        // When route includes any wildcard segments in the middle.
+        if (normalizedRoute.includes('/*/')) {
+            printWarning(route);
+            // Replace each /*/ segment with a named parameter using different name for each segment.
+            return route.replaceAll('/*/', (match, offset) => {
+                return `/*path${offset}/`;
+            });
+        }
+        return route;
+    }
+    static printError(route) {
+        this.logger.error(UNSUPPORTED_PATH_MESSAGE `${route}`);
+    }
+    static printWarning(route) {
+        this.logger.warn(UNSUPPORTED_PATH_MESSAGE `${route}` + ' Attempting to auto-convert...');
+    }
+}
+exports.LegacyRouteConverter = LegacyRouteConverter;
+LegacyRouteConverter.logger = new common_1.Logger(LegacyRouteConverter.name);

package/router/paths-explorer.d.ts

@@ -0,0 +1,18 @@
+import { RequestMethod } from '@nestjs/common/enums';
+import { Controller } from '@nestjs/common/interfaces/controllers/controller.interface';
+import { VersionValue } from '@nestjs/common/interfaces/version-options.interface';
+import { MetadataScanner } from '../metadata-scanner';
+import { RouterProxyCallback } from './router-proxy';
+export interface RouteDefinition {
+    path: string[];
+    requestMethod: RequestMethod;
+    targetCallback: RouterProxyCallback;
+    methodName: string;
+    version?: VersionValue;
+}
+export declare class PathsExplorer {
+    private readonly metadataScanner;
+    constructor(metadataScanner: MetadataScanner);
+    scanForPaths(instance: Controller, prototype?: object): RouteDefinition[];
+    exploreMethodMetadata(instance: Controller, prototype: object, methodName: string): RouteDefinition | null;
+}

package/router/paths-explorer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathsExplorer = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+class PathsExplorer {
+    constructor(metadataScanner) {
+        this.metadataScanner = metadataScanner;
+    }
+    scanForPaths(instance, prototype) {
+        const instancePrototype = (0, shared_utils_1.isUndefined)(prototype)
+            ? Object.getPrototypeOf(instance)
+            : prototype;
+        return this.metadataScanner
+            .getAllMethodNames(instancePrototype)
+            .reduce((acc, method) => {
+            const route = this.exploreMethodMetadata(instance, instancePrototype, method);
+            if (route) {
+                acc.push(route);
+            }
+            return acc;
+        }, []);
+    }
+    exploreMethodMetadata(instance, prototype, methodName) {
+        const instanceCallback = instance[methodName];
+        const prototypeCallback = prototype[methodName];
+        const routePath = Reflect.getMetadata(constants_1.PATH_METADATA, prototypeCallback);
+        if ((0, shared_utils_1.isUndefined)(routePath)) {
+            return null;
+        }
+        const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, prototypeCallback);
+        const version = Reflect.getMetadata(constants_1.VERSION_METADATA, prototypeCallback);
+        const path = (0, shared_utils_1.isString)(routePath)
+            ? [(0, shared_utils_1.addLeadingSlash)(routePath)]
+            : routePath.map((p) => (0, shared_utils_1.addLeadingSlash)(p));
+        return {
+            path,
+            requestMethod,
+            targetCallback: instanceCallback,
+            methodName,
+            version,
+        };
+    }
+}
+exports.PathsExplorer = PathsExplorer;

package/router/request/index.d.ts

@@ -0,0 +1 @@
+export { REQUEST } from './request-constants';

package/router/request/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUEST = void 0;
+var request_constants_1 = require("./request-constants");
+Object.defineProperty(exports, "REQUEST", { enumerable: true, get: function () { return request_constants_1.REQUEST; } });

package/router/request/request-constants.d.ts

@@ -0,0 +1,2 @@
+export declare const REQUEST = "REQUEST";
+export declare const REQUEST_CONTEXT_ID: unique symbol;

package/router/request/request-constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUEST_CONTEXT_ID = exports.REQUEST = void 0;
+exports.REQUEST = 'REQUEST';
+exports.REQUEST_CONTEXT_ID = Symbol('REQUEST_CONTEXT_ID');

package/router/request/request-providers.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '@nestjs/common';
+export declare const requestProvider: Provider;

package/router/request/request-providers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestProvider = void 0;
+const common_1 = require("@nestjs/common");
+const request_constants_1 = require("./request-constants");
+const noop = () => { };
+exports.requestProvider = {
+    provide: request_constants_1.REQUEST,
+    scope: common_1.Scope.REQUEST,
+    useFactory: noop,
+};

package/router/route-params-factory.d.ts

@@ -0,0 +1,9 @@
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
+import { IRouteParamsFactory } from './interfaces/route-params-factory.interface';
+export declare class RouteParamsFactory implements IRouteParamsFactory {
+    exchangeKeyForValue<TRequest extends Record<string, any> = any, TResponse = any, TResult = any>(key: RouteParamtypes | string, data: string, { req, res, next }: {
+        req: TRequest;
+        res: TResponse;
+        next: Function;
+    }): TResult | null;
+}