@depup/nestjs__core 11.1.17-depup.0

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@depup/nestjs__core",
+  "version": "11.1.17-depup.0",
+  "description": "[DepUp] Nest - modern, fast, powerful node.js web framework (@core)",
+  "author": "Kamil Mysliwiec",
+  "license": "MIT",
+  "homepage": "https://nestjs.com",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/nest"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nestjs/nest.git",
+    "directory": "packages/core"
+  },
+  "scripts": {},
+  "collective": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/nest",
+    "donation": {
+      "text": "Become a partner:"
+    }
+  },
+  "dependencies": {
+    "@nuxt/opencollective": "0.4.1",
+    "fast-safe-stringify": "2.1.1",
+    "iterare": "1.2.1",
+    "path-to-regexp": "8.3.0",
+    "tslib": "2.8.1",
+    "uid": "2.0.2"
+  },
+  "devDependencies": {
+    "@nestjs/common": "11.1.17"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/microservices": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "@nestjs/websockets": "^11.0.0",
+    "reflect-metadata": "^0.1.12 || ^0.2.0",
+    "rxjs": "^7.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@nestjs/websockets": {
+      "optional": true
+    },
+    "@nestjs/microservices": {
+      "optional": true
+    },
+    "@nestjs/platform-express": {
+      "optional": true
+    }
+  },
+  "gitHead": "447a373ebebd2c58b5b3c8d718f25922a025f2fe",
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "@nestjs/core"
+  ],
+  "depup": {
+    "changes": {},
+    "depsUpdated": 0,
+    "originalPackage": "@nestjs/core",
+    "originalVersion": "11.1.17",
+    "processedAt": "2026-03-16T12:24:07.904Z",
+    "smokeTest": "failed"
+  }
+}

package/pipes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './params-token-factory';
+export * from './pipes-consumer';
+export * from './pipes-context-creator';

package/pipes/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./params-token-factory"), exports);
+tslib_1.__exportStar(require("./pipes-consumer"), exports);
+tslib_1.__exportStar(require("./pipes-context-creator"), exports);

package/pipes/params-token-factory.d.ts

@@ -0,0 +1,5 @@
+import { Paramtype } from '@nestjs/common';
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
+export declare class ParamsTokenFactory {
+    exchangeEnumForString(type: RouteParamtypes): Paramtype;
+}

package/pipes/params-token-factory.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamsTokenFactory = void 0;
+const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
+class ParamsTokenFactory {
+    exchangeEnumForString(type) {
+        switch (type) {
+            case route_paramtypes_enum_1.RouteParamtypes.BODY:
+                return 'body';
+            case route_paramtypes_enum_1.RouteParamtypes.PARAM:
+                return 'param';
+            case route_paramtypes_enum_1.RouteParamtypes.QUERY:
+                return 'query';
+            default:
+                return 'custom';
+        }
+    }
+}
+exports.ParamsTokenFactory = ParamsTokenFactory;

package/pipes/pipes-consumer.d.ts

@@ -0,0 +1,10 @@
+import { ArgumentMetadata, PipeTransform } from '@nestjs/common/interfaces';
+export declare class PipesConsumer {
+    private readonly paramsTokenFactory;
+    apply<TInput = unknown>(value: TInput, { metatype, type, data }: ArgumentMetadata, pipes: PipeTransform[]): Promise<any>;
+    applyPipes<TInput = unknown>(value: TInput, { metatype, type, data }: {
+        metatype: any;
+        type?: any;
+        data?: any;
+    }, transforms: PipeTransform[]): Promise<any>;
+}

package/pipes/pipes-consumer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipesConsumer = void 0;
+const params_token_factory_1 = require("./params-token-factory");
+class PipesConsumer {
+    constructor() {
+        this.paramsTokenFactory = new params_token_factory_1.ParamsTokenFactory();
+    }
+    async apply(value, { metatype, type, data }, pipes) {
+        const token = this.paramsTokenFactory.exchangeEnumForString(type);
+        return this.applyPipes(value, { metatype, type: token, data }, pipes);
+    }
+    async applyPipes(value, { metatype, type, data }, transforms) {
+        return transforms.reduce(async (deferredValue, pipe) => {
+            const val = await deferredValue;
+            const result = pipe.transform(val, { metatype, type, data });
+            return result;
+        }, Promise.resolve(value));
+    }
+}
+exports.PipesConsumer = PipesConsumer;

package/pipes/pipes-context-creator.d.ts

@@ -0,0 +1,17 @@
+import { Controller, PipeTransform, Type } from '@nestjs/common/interfaces';
+import { ApplicationConfig } from '../application-config';
+import { ContextCreator } from '../helpers/context-creator';
+import { NestContainer } from '../injector/container';
+import { InstanceWrapper } from '../injector/instance-wrapper';
+export declare class PipesContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: NestContainer, config?: ApplicationConfig | undefined);
+    create(instance: Controller, callback: (...args: unknown[]) => unknown, moduleKey: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): PipeTransform[];
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
+    getPipeInstance(pipe: Function | PipeTransform, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): PipeTransform | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+    setModuleContext(context: string): void;
+}

package/pipes/pipes-context-creator.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipesContextCreator = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const context_creator_1 = require("../helpers/context-creator");
+const constants_2 = require("../injector/constants");
+class PipesContextCreator extends context_creator_1.ContextCreator {
+    constructor(container, config) {
+        super();
+        this.container = container;
+        this.config = config;
+    }
+    create(instance, callback, moduleKey, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = moduleKey;
+        return this.createContext(instance, callback, constants_1.PIPES_METADATA, contextId, inquirerId);
+    }
+    createConcreteContext(metadata, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if ((0, shared_utils_1.isEmpty)(metadata)) {
+            return [];
+        }
+        return (0, iterare_1.iterate)(metadata)
+            .filter((pipe) => pipe && (pipe.name || pipe.transform))
+            .map(pipe => this.getPipeInstance(pipe, contextId, inquirerId))
+            .filter(pipe => !!pipe && pipe.transform && (0, shared_utils_1.isFunction)(pipe.transform))
+            .toArray();
+    }
+    getPipeInstance(pipe, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const isObject = !!pipe.transform;
+        if (isObject) {
+            return pipe;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(pipe);
+        if (!instanceWrapper) {
+            return null;
+        }
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        return instanceHost && instanceHost.instance;
+    }
+    getInstanceByMetatype(metatype) {
+        if (!this.moduleContext) {
+            return;
+        }
+        const collection = this.container.getModules();
+        const moduleRef = collection.get(this.moduleContext);
+        if (!moduleRef) {
+            return;
+        }
+        return moduleRef.injectables.get(metatype);
+    }
+    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if (!this.config) {
+            return [];
+        }
+        const globalPipes = this.config.getGlobalPipes();
+        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+            return globalPipes;
+        }
+        const scopedPipeWrappers = this.config.getGlobalRequestPipes();
+        const scopedPipes = (0, iterare_1.iterate)(scopedPipeWrappers)
+            .map(wrapper => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
+            .filter(host => !!host)
+            .map(host => host.instance)
+            .toArray();
+        return globalPipes.concat(scopedPipes);
+    }
+    setModuleContext(context) {
+        this.moduleContext = context;
+    }
+}
+exports.PipesContextCreator = PipesContextCreator;

package/repl/assign-to-object.util.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Similar to `Object.assign` but copying properties descriptors from `source`
+ * as well.
+ */
+export declare function assignToObject<T, U extends object>(target: T, source: U): T & U;

package/repl/assign-to-object.util.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignToObject = assignToObject;
+/**
+ * Similar to `Object.assign` but copying properties descriptors from `source`
+ * as well.
+ */
+function assignToObject(target, source) {
+    Object.defineProperties(target, Object.keys(source).reduce((descriptors, key) => {
+        descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
+        return descriptors;
+    }, Object.create(null)));
+    return target;
+}

package/repl/constants.d.ts

@@ -0,0 +1 @@
+export declare const REPL_INITIALIZED_MESSAGE = "REPL initialized";

package/repl/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPL_INITIALIZED_MESSAGE = void 0;
+exports.REPL_INITIALIZED_MESSAGE = 'REPL initialized';

package/repl/index.d.ts

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

package/repl/index.js

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

package/repl/native-functions/debug-repl-fn.d.ts

@@ -0,0 +1,9 @@
+import type { Type } from '@nestjs/common';
+import { ReplFunction } from '../repl-function';
+import type { ReplFnDefinition } from '../repl.interfaces';
+export declare class DebugReplFn extends ReplFunction {
+    fnDefinition: ReplFnDefinition;
+    action(moduleCls?: Type<unknown> | string): void;
+    private printCtrlsAndProviders;
+    private printCollection;
+}

package/repl/native-functions/debug-repl-fn.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugReplFn = void 0;
+const cli_colors_util_1 = require("@nestjs/common/utils/cli-colors.util");
+const repl_function_1 = require("../repl-function");
+class DebugReplFn extends repl_function_1.ReplFunction {
+    constructor() {
+        super(...arguments);
+        this.fnDefinition = {
+            name: 'debug',
+            description: 'Print all registered modules as a list together with their controllers and providers.\nIf the argument is passed in, for example, "debug(MyModule)" then it will only print components of this specific module.',
+            signature: '(moduleCls?: ClassRef | string) => void',
+        };
+    }
+    action(moduleCls) {
+        this.ctx.writeToStdout('\n');
+        if (moduleCls) {
+            const token = typeof moduleCls === 'function' ? moduleCls.name : moduleCls;
+            const moduleEntry = this.ctx.debugRegistry[token];
+            if (!moduleEntry) {
+                return this.logger.error(`"${token}" has not been found in the modules registry`);
+            }
+            this.printCtrlsAndProviders(token, moduleEntry);
+        }
+        else {
+            Object.keys(this.ctx.debugRegistry).forEach(moduleKey => {
+                this.printCtrlsAndProviders(moduleKey, this.ctx.debugRegistry[moduleKey]);
+            });
+        }
+        this.ctx.writeToStdout('\n');
+    }
+    printCtrlsAndProviders(moduleName, moduleDebugEntry) {
+        this.ctx.writeToStdout(`${cli_colors_util_1.clc.green(moduleName)}:\n`);
+        this.printCollection('controllers', moduleDebugEntry['controllers']);
+        this.printCollection('providers', moduleDebugEntry['providers']);
+    }
+    printCollection(title, collectionValue) {
+        const collectionEntries = Object.keys(collectionValue);
+        if (collectionEntries.length <= 0) {
+            return;
+        }
+        this.ctx.writeToStdout(` ${cli_colors_util_1.clc.yellow(`- ${title}`)}:\n`);
+        collectionEntries.forEach(provider => this.ctx.writeToStdout(`  ${cli_colors_util_1.clc.green('◻')} ${provider}\n`));
+    }
+}
+exports.DebugReplFn = DebugReplFn;

package/repl/native-functions/get-repl-fn.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from '@nestjs/common';
+import { ReplFunction } from '../repl-function';
+import type { ReplFnDefinition } from '../repl.interfaces';
+export declare class GetReplFn extends ReplFunction {
+    fnDefinition: ReplFnDefinition;
+    action(token: string | symbol | Function | Type<any>): any;
+}

package/repl/native-functions/get-repl-fn.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetReplFn = void 0;
+const repl_function_1 = require("../repl-function");
+class GetReplFn extends repl_function_1.ReplFunction {
+    constructor() {
+        super(...arguments);
+        this.fnDefinition = {
+            name: 'get',
+            signature: '(token: InjectionToken) => any',
+            description: 'Retrieves an instance of either injectable or controller, otherwise, throws exception.',
+            aliases: ['$'],
+        };
+    }
+    action(token) {
+        return this.ctx.app.get(token);
+    }
+}
+exports.GetReplFn = GetReplFn;

package/repl/native-functions/help-repl-fn.d.ts

@@ -0,0 +1,7 @@
+import { ReplFunction } from '../repl-function';
+import type { ReplFnDefinition } from '../repl.interfaces';
+export declare class HelpReplFn extends ReplFunction {
+    fnDefinition: ReplFnDefinition;
+    static buildHelpMessage: ({ name, description }: ReplFnDefinition) => string;
+    action(): void;
+}

package/repl/native-functions/help-repl-fn.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpReplFn = void 0;
+const iterare_1 = require("iterare");
+const cli_colors_util_1 = require("@nestjs/common/utils/cli-colors.util");
+const repl_function_1 = require("../repl-function");
+class HelpReplFn extends repl_function_1.ReplFunction {
+    constructor() {
+        super(...arguments);
+        this.fnDefinition = {
+            name: 'help',
+            signature: '() => void',
+            description: 'Display all available REPL native functions.',
+        };
+    }
+    action() {
+        const sortedNativeFunctions = (0, iterare_1.iterate)(this.ctx.nativeFunctions)
+            .map(([, nativeFunction]) => nativeFunction.fnDefinition)
+            .toArray()
+            .sort((a, b) => (a.name < b.name ? -1 : 1));
+        this.ctx.writeToStdout(`You can call ${cli_colors_util_1.clc.bold('.help')} on any function listed below (e.g.: ${cli_colors_util_1.clc.bold('help.help')}):\n\n` +
+            sortedNativeFunctions.map(HelpReplFn.buildHelpMessage).join('\n') +
+            // Without the following LF the last item won't be displayed
+            '\n');
+    }
+}
+exports.HelpReplFn = HelpReplFn;
+HelpReplFn.buildHelpMessage = ({ name, description }) => cli_colors_util_1.clc.cyanBright(name) +
+    (description ? ` ${cli_colors_util_1.clc.bold('-')} ${description}` : '');

package/repl/native-functions/index.d.ts

@@ -0,0 +1,6 @@
+export * from './help-repl-fn';
+export * from './get-repl-fn';
+export * from './resolve-repl-fn';
+export * from './select-relp-fn';
+export * from './debug-repl-fn';
+export * from './methods-repl-fn';

package/repl/native-functions/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./help-repl-fn"), exports);
+tslib_1.__exportStar(require("./get-repl-fn"), exports);
+tslib_1.__exportStar(require("./resolve-repl-fn"), exports);
+tslib_1.__exportStar(require("./select-relp-fn"), exports);
+tslib_1.__exportStar(require("./debug-repl-fn"), exports);
+tslib_1.__exportStar(require("./methods-repl-fn"), exports);

package/repl/native-functions/methods-repl-fn.d.ts

@@ -0,0 +1,8 @@
+import type { Type } from '@nestjs/common';
+import { ReplFunction } from '../repl-function';
+import type { ReplFnDefinition } from '../repl.interfaces';
+export declare class MethodsReplFn extends ReplFunction {
+    fnDefinition: ReplFnDefinition;
+    private readonly metadataScanner;
+    action(token: Type<unknown> | string): void;
+}

package/repl/native-functions/methods-repl-fn.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodsReplFn = void 0;
+const cli_colors_util_1 = require("@nestjs/common/utils/cli-colors.util");
+const metadata_scanner_1 = require("../../metadata-scanner");
+const repl_function_1 = require("../repl-function");
+class MethodsReplFn extends repl_function_1.ReplFunction {
+    constructor() {
+        super(...arguments);
+        this.fnDefinition = {
+            name: 'methods',
+            description: 'Display all public methods available on a given provider or controller.',
+            signature: '(token: ClassRef | string) => void',
+        };
+        this.metadataScanner = new metadata_scanner_1.MetadataScanner();
+    }
+    action(token) {
+        const proto = typeof token !== 'function'
+            ? Object.getPrototypeOf(this.ctx.app.get(token))
+            : token?.prototype;
+        const methods = this.metadataScanner.getAllMethodNames(proto);
+        this.ctx.writeToStdout('\n');
+        this.ctx.writeToStdout(`${cli_colors_util_1.clc.green('Methods')}:\n`);
+        methods.forEach(methodName => this.ctx.writeToStdout(` ${cli_colors_util_1.clc.yellow('◻')} ${methodName}\n`));
+        this.ctx.writeToStdout('\n');
+    }
+}
+exports.MethodsReplFn = MethodsReplFn;

package/repl/native-functions/resolve-repl-fn.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from '@nestjs/common';
+import { ReplFunction } from '../repl-function';
+import type { ReplFnDefinition } from '../repl.interfaces';
+export declare class ResolveReplFn extends ReplFunction {
+    fnDefinition: ReplFnDefinition;
+    action(token: string | symbol | Function | Type<any>, contextId: any): Promise<any>;
+}

package/repl/native-functions/resolve-repl-fn.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveReplFn = void 0;
+const repl_function_1 = require("../repl-function");
+class ResolveReplFn extends repl_function_1.ReplFunction {
+    constructor() {
+        super(...arguments);
+        this.fnDefinition = {
+            name: 'resolve',
+            description: 'Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.',
+            signature: '(token: InjectionToken, contextId: any) => Promise<any>',
+        };
+    }
+    action(token, contextId) {
+        return this.ctx.app.resolve(token, contextId);
+    }
+}
+exports.ResolveReplFn = ResolveReplFn;

package/repl/native-functions/select-relp-fn.d.ts

@@ -0,0 +1,7 @@
+import type { DynamicModule, INestApplicationContext, Type } from '@nestjs/common';
+import { ReplFunction } from '../repl-function';
+import type { ReplFnDefinition } from '../repl.interfaces';
+export declare class SelectReplFn extends ReplFunction {
+    fnDefinition: ReplFnDefinition;
+    action(token: DynamicModule | Type<unknown>): INestApplicationContext;
+}

package/repl/native-functions/select-relp-fn.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectReplFn = void 0;
+const repl_function_1 = require("../repl-function");
+class SelectReplFn extends repl_function_1.ReplFunction {
+    constructor() {
+        super(...arguments);
+        this.fnDefinition = {
+            name: 'select',
+            description: 'Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.',
+            signature: '(token: DynamicModule | ClassRef) => INestApplicationContext',
+        };
+    }
+    action(token) {
+        return this.ctx.app.select(token);
+    }
+}
+exports.SelectReplFn = SelectReplFn;

package/repl/repl-context.d.ts

@@ -0,0 +1,26 @@
+import { INestApplicationContext, InjectionToken, Logger } from '@nestjs/common';
+import { ReplFunction } from './repl-function';
+import type { ReplFunctionClass } from './repl.interfaces';
+type ModuleKey = string;
+export type ModuleDebugEntry = {
+    controllers: Record<string, InjectionToken>;
+    providers: Record<string, InjectionToken>;
+};
+type ReplScope = Record<string, any>;
+export declare class ReplContext {
+    readonly app: INestApplicationContext;
+    readonly logger: Logger;
+    debugRegistry: Record<ModuleKey, ModuleDebugEntry>;
+    readonly globalScope: ReplScope;
+    readonly nativeFunctions: Map<string, ReplFunction<unknown[], any>>;
+    private readonly container;
+    constructor(app: INestApplicationContext, nativeFunctionsClassRefs?: ReplFunctionClass[]);
+    writeToStdout(text: string): void;
+    private initializeContext;
+    private introspectCollection;
+    private stringifyToken;
+    private addNativeFunction;
+    private registerFunctionIntoGlobalScope;
+    private initializeNativeFunctions;
+}
+export {};