@nestjs/core 11.1.3 → 11.1.4

package/adapters/http-adapter.d.ts

@@ -7,6 +7,7 @@ import { NestApplicationOptions } from '@nestjs/common/interfaces/nest-applicati
 export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any, TResponse = any> implements HttpServer<TRequest, TResponse> {
     protected instance?: any | undefined;
     protected httpServer: TServer;
+    protected onRouteTriggered: ((requestMethod: RequestMethod, path: string) => void) | undefined;
     constructor(instance?: any | undefined);
     init(): Promise<void>;
     use(...args: any[]): any;
@@ -49,6 +50,10 @@ export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any,
     setInstance<T = any>(instance: T): void;
     getInstance<T = any>(): T;
     normalizePath(path: string): string;
+    setOnRouteTriggered(onRouteTriggered: (requestMethod: RequestMethod, path: string) => void): void;
+    getOnRouteTriggered(): ((requestMethod: RequestMethod, path: string) => void) | undefined;
+    setOnRequestHook(onRequestHook: Function): void;
+    setOnResponseHook(onResponseHook: Function): void;
     abstract close(): any;
     abstract initHttpServer(options: NestApplicationOptions): any;
     abstract useStaticAssets(...args: any[]): any;

package/adapters/http-adapter.js

@@ -78,5 +78,13 @@ class AbstractHttpAdapter {
     normalizePath(path) {
         return path;
     }
+    setOnRouteTriggered(onRouteTriggered) {
+        this.onRouteTriggered = onRouteTriggered;
+    }
+    getOnRouteTriggered() {
+        return this.onRouteTriggered;
+    }
+    setOnRequestHook(onRequestHook) { }
+    setOnResponseHook(onResponseHook) { }
 }
 exports.AbstractHttpAdapter = AbstractHttpAdapter;

package/guards/guards-consumer.js

@@ -13,6 +13,12 @@ class GuardsConsumer {
         context.setType(type);
         for (const guard of guards) {
             const result = guard.canActivate(context);
+            if (typeof result === 'boolean') {
+                if (!result) {
+                    return false;
+                }
+                continue;
+            }
             if (await this.pickResult(result)) {
                 continue;
             }

package/helpers/barrier.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A simple barrier to synchronize flow of multiple async operations.
+ */
+export declare class Barrier {
+    private currentCount;
+    private targetCount;
+    private promise;
+    private resolve;
+    constructor(targetCount: number);
+    /**
+     * Signal that a participant has reached the barrier.
+     *
+     * The barrier will be resolved once `targetCount` participants have reached it.
+     */
+    signal(): void;
+    /**
+     * Wait for the barrier to be resolved.
+     *
+     * @returns A promise that resolves when the barrier is resolved.
+     */
+    wait(): Promise<void>;
+    /**
+     * Signal that a participant has reached the barrier and wait for the barrier to be resolved.
+     *
+     * The barrier will be resolved once `targetCount` participants have reached it.
+     *
+     * @returns A promise that resolves when the barrier is resolved.
+     */
+    signalAndWait(): Promise<void>;
+}

package/helpers/barrier.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Barrier = void 0;
+/**
+ * A simple barrier to synchronize flow of multiple async operations.
+ */
+class Barrier {
+    constructor(targetCount) {
+        this.currentCount = 0;
+        this.targetCount = targetCount;
+        this.promise = new Promise(resolve => {
+            this.resolve = resolve;
+        });
+    }
+    /**
+     * Signal that a participant has reached the barrier.
+     *
+     * The barrier will be resolved once `targetCount` participants have reached it.
+     */
+    signal() {
+        this.currentCount += 1;
+        if (this.currentCount === this.targetCount) {
+            this.resolve();
+        }
+    }
+    /**
+     * Wait for the barrier to be resolved.
+     *
+     * @returns A promise that resolves when the barrier is resolved.
+     */
+    async wait() {
+        return this.promise;
+    }
+    /**
+     * Signal that a participant has reached the barrier and wait for the barrier to be resolved.
+     *
+     * The barrier will be resolved once `targetCount` participants have reached it.
+     *
+     * @returns A promise that resolves when the barrier is resolved.
+     */
+    async signalAndWait() {
+        this.signal();
+        return this.wait();
+    }
+}
+exports.Barrier = Barrier;

package/helpers/http-adapter-host.d.ts

@@ -15,6 +15,7 @@ import { AbstractHttpAdapter } from '../adapters/http-adapter';
 export declare class HttpAdapterHost<T extends AbstractHttpAdapter = AbstractHttpAdapter> {
     private _httpAdapter?;
     private _listen$;
+    private _init$;
     private isListening;
     /**
      * Accessor for the underlying `HttpAdapter`
@@ -34,6 +35,11 @@ export declare class HttpAdapterHost<T extends AbstractHttpAdapter = AbstractHtt
      * This event is emitted when the HTTP application is listening for incoming requests.
      */
     get listen$(): Observable<void>;
+    /**
+     * Observable that allows to subscribe to the `init` event.
+     * This event is emitted when the HTTP application is initialized.
+     */
+    get init$(): Observable<void>;
     /**
      * Sets the listening state of the application.
      */

package/helpers/http-adapter-host.js

@@ -17,6 +17,7 @@ const rxjs_1 = require("rxjs");
 class HttpAdapterHost {
     constructor() {
         this._listen$ = new rxjs_1.Subject();
+        this._init$ = new rxjs_1.ReplaySubject();
         this.isListening = false;
     }
     /**
@@ -26,6 +27,8 @@ class HttpAdapterHost {
      */
     set httpAdapter(httpAdapter) {
         this._httpAdapter = httpAdapter;
+        this._init$.next();
+        this._init$.complete();
     }
     /**
      * Accessor for the underlying `HttpAdapter`
@@ -43,6 +46,13 @@ class HttpAdapterHost {
     get listen$() {
         return this._listen$.asObservable();
     }
+    /**
+     * Observable that allows to subscribe to the `init` event.
+     * This event is emitted when the HTTP application is initialized.
+     */
+    get init$() {
+        return this._init$.asObservable();
+    }
     /**
      * Sets the listening state of the application.
      */

package/injector/container.d.ts

@@ -24,6 +24,7 @@ export declare class NestContainer {
     constructor(_applicationConfig?: ApplicationConfig | undefined, _contextOptions?: NestApplicationContextOptions | undefined);
     get serializedGraph(): SerializedGraph;
     get applicationConfig(): ApplicationConfig | undefined;
+    get contextOptions(): NestApplicationContextOptions | undefined;
     setHttpAdapter(httpAdapter: any): void;
     getHttpAdapterRef(): import("..").AbstractHttpAdapter<any, any, any>;
     getHttpAdapterHostRef(): import("..").HttpAdapterHost<import("..").AbstractHttpAdapter<any, any, any>>;

package/injector/container.js

@@ -38,6 +38,9 @@ class NestContainer {
     get applicationConfig() {
         return this._applicationConfig;
     }
+    get contextOptions() {
+        return this._contextOptions;
+    }
     setHttpAdapter(httpAdapter) {
         this.internalProvidersStorage.httpAdapter = httpAdapter;
         if (!this.internalProvidersStorage.httpAdapterHost) {

package/injector/injector.d.ts

@@ -42,8 +42,16 @@ export interface InjectorDependencyContext {
 export declare class Injector {
     private readonly options?;
     private logger;
+    private readonly instanceDecorator;
     constructor(options?: {
+        /**
+         * Whether to enable preview mode.
+         */
         preview: boolean;
+        /**
+         * Function to decorate a freshly created instance.
+         */
+        instanceDecorator?: (target: unknown) => unknown;
     } | undefined);
     loadPrototype<T>({ token }: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper<T>>, contextId?: ContextId): void;
     loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
@@ -60,7 +68,7 @@ export declare class Injector {
     reflectSelfParams<T>(type: Type<T>): any[];
     resolveSingleParam<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol, dependencyContext: InjectorDependencyContext, moduleRef: Module, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<any>>;
     resolveParamToken<T>(wrapper: InstanceWrapper<T>, param: Type<any> | string | symbol | ForwardReference): any;
-    resolveComponentInstance<T>(moduleRef: Module, token: InjectionToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
+    resolveComponentWrapper<T>(moduleRef: Module, token: InjectionToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
     resolveComponentHost<T>(moduleRef: Module, instanceWrapper: InstanceWrapper<T | Promise<T>>, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<InstanceWrapper>;
     lookupComponent<T = any>(providers: Map<Function | string | symbol, InstanceWrapper>, moduleRef: Module, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<T>>;
     lookupComponentInParentModules<T = any>(dependencyContext: InjectorDependencyContext, moduleRef: Module, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<any>;

package/injector/injector.js

@@ -15,10 +15,15 @@ const constants_2 = require("./constants");
 const inquirer_1 = require("./inquirer");
 const instance_wrapper_1 = require("./instance-wrapper");
 const settlement_signal_1 = require("./settlement-signal");
+const barrier_1 = require("../helpers/barrier");
 class Injector {
     constructor(options) {
         this.options = options;
         this.logger = new common_1.Logger('InjectorLogger');
+        this.instanceDecorator = (target) => target;
+        if (options?.instanceDecorator) {
+            this.instanceDecorator = options.instanceDecorator;
+        }
     }
     loadPrototype({ token }, collection, contextId = constants_2.STATIC_CONTEXT) {
         if (!collection) {
@@ -116,10 +121,15 @@ class Injector {
         const [dependencies, optionalDependenciesIds] = isFactoryProvider
             ? this.getFactoryProviderDependencies(wrapper)
             : this.getClassDependencies(wrapper);
+        const paramBarrier = new barrier_1.Barrier(dependencies.length);
         let isResolved = true;
         const resolveParam = async (param, index) => {
             try {
                 if (this.isInquirer(param, parentInquirer)) {
+                    /*
+                     * Signal the barrier to make sure other dependencies do not get stuck waiting forever.
+                     */
+                    paramBarrier.signal();
                     return parentInquirer && parentInquirer.instance;
                 }
                 if (inquirer?.isTransient && parentInquirer) {
@@ -127,13 +137,26 @@ class Injector {
                     inquirerId = this.getInquirerId(parentInquirer);
                 }
                 const paramWrapper = await this.resolveSingleParam(wrapper, param, { index, dependencies }, moduleRef, contextId, inquirer, index);
-                const instanceHost = paramWrapper.getInstanceByContextId(this.getContextId(contextId, paramWrapper), inquirerId);
-                if (!instanceHost.isResolved && !paramWrapper.forwardRef) {
+                /*
+                 * Ensure that all instance wrappers are resolved at this point before we continue.
+                 * Otherwise the staticity of `wrapper`'s dependency tree may be evaluated incorrectly
+                 * and result in undefined / null injection.
+                 */
+                await paramBarrier.signalAndWait();
+                const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, contextId, inquirer);
+                const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(contextId, paramWrapperWithInstance), inquirerId);
+                if (!instanceHost.isResolved && !paramWrapperWithInstance.forwardRef) {
                     isResolved = false;
                 }
                 return instanceHost?.instance;
             }
             catch (err) {
+                /*
+                 * Signal the barrier to make sure other dependencies do not get stuck waiting forever. We
+                 * do not care if this occurs after `Barrier.signalAndWait()` is called in the `try` block
+                 * because the barrier will always have been resolved by then.
+                 */
+                paramBarrier.signal();
                 const isOptional = optionalDependenciesIds.includes(index);
                 if (!isOptional) {
                     throw err;
@@ -199,7 +222,7 @@ class Injector {
             throw new undefined_dependency_exception_1.UndefinedDependencyException(wrapper.name, dependencyContext, moduleRef);
         }
         const token = this.resolveParamToken(wrapper, param);
-        return this.resolveComponentInstance(moduleRef, token, dependencyContext, wrapper, contextId, inquirer, keyOrIndex);
+        return this.resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId, inquirer, keyOrIndex);
     }
     resolveParamToken(wrapper, param) {
         if (typeof param === 'object' && 'forwardRef' in param) {
@@ -208,12 +231,11 @@ class Injector {
         }
         return param;
     }
-    async resolveComponentInstance(moduleRef, token, dependencyContext, wrapper, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
+    async resolveComponentWrapper(moduleRef, token, dependencyContext, wrapper, contextId = constants_2.STATIC_CONTEXT, inquirer, keyOrIndex) {
         this.printResolvingDependenciesLog(token, inquirer);
         this.printLookingForProviderLog(token, moduleRef);
         const providers = moduleRef.providers;
-        const instanceWrapper = await this.lookupComponent(providers, moduleRef, { ...dependencyContext, name: token }, wrapper, contextId, inquirer, keyOrIndex);
-        return this.resolveComponentHost(moduleRef, instanceWrapper, contextId, inquirer);
+        return this.lookupComponent(providers, moduleRef, { ...dependencyContext, name: token }, wrapper, contextId, inquirer, keyOrIndex);
     }
     async resolveComponentHost(moduleRef, instanceWrapper, contextId = constants_2.STATIC_CONTEXT, inquirer) {
         const inquirerId = this.getInquirerId(inquirer);
@@ -309,6 +331,7 @@ class Injector {
             return this.loadPropertiesMetadata(metadata, contextId, inquirer);
         }
         const properties = this.reflectProperties(wrapper.metatype);
+        const propertyBarrier = new barrier_1.Barrier(properties.length);
         const instances = await Promise.all(properties.map(async (item) => {
             try {
                 const dependencyContext = {
@@ -316,17 +339,34 @@ class Injector {
                     name: item.name,
                 };
                 if (this.isInquirer(item.name, parentInquirer)) {
+                    /*
+                     * Signal the barrier to make sure other dependencies do not get stuck waiting forever.
+                     */
+                    propertyBarrier.signal();
                     return parentInquirer && parentInquirer.instance;
                 }
                 const paramWrapper = await this.resolveSingleParam(wrapper, item.name, dependencyContext, moduleRef, contextId, inquirer, item.key);
-                if (!paramWrapper) {
+                /*
+                 * Ensure that all instance wrappers are resolved at this point before we continue.
+                 * Otherwise the staticity of `wrapper`'s dependency tree may be evaluated incorrectly
+                 * and result in undefined / null injection.
+                 */
+                await propertyBarrier.signalAndWait();
+                const paramWrapperWithInstance = await this.resolveComponentHost(moduleRef, paramWrapper, contextId, inquirer);
+                if (!paramWrapperWithInstance) {
                     return undefined;
                 }
                 const inquirerId = this.getInquirerId(inquirer);
-                const instanceHost = paramWrapper.getInstanceByContextId(this.getContextId(contextId, paramWrapper), inquirerId);
+                const instanceHost = paramWrapperWithInstance.getInstanceByContextId(this.getContextId(contextId, paramWrapperWithInstance), inquirerId);
                 return instanceHost.instance;
             }
             catch (err) {
+                /*
+                 * Signal the barrier to make sure other dependencies do not get stuck waiting forever. We
+                 * do not care if this occurs after `Barrier.signalAndWait()` is called in the `try` block
+                 * because the barrier will always have been resolved by then.
+                 */
+                propertyBarrier.signal();
                 if (!item.isOptional) {
                     throw err;
                 }
@@ -371,10 +411,12 @@ class Injector {
             instanceHost.instance = wrapper.forwardRef
                 ? Object.assign(instanceHost.instance, new metatype(...instances))
                 : new metatype(...instances);
+            instanceHost.instance = this.instanceDecorator(instanceHost.instance);
         }
         else if (isInContext) {
             const factoryReturnValue = targetMetatype.metatype(...instances);
             instanceHost.instance = await factoryReturnValue;
+            instanceHost.instance = this.instanceDecorator(instanceHost.instance);
         }
         instanceHost.isResolved = true;
         return instanceHost.instance;

package/injector/internal-core-module/internal-core-module-factory.js

@@ -17,7 +17,10 @@ class InternalCoreModuleFactory {
             const logger = new common_1.Logger(lazy_module_loader_1.LazyModuleLoader.name, {
                 timestamp: false,
             });
-            const injector = new injector_1.Injector();
+            const injector = new injector_1.Injector({
+                preview: container.contextOptions?.preview,
+                instanceDecorator: container.contextOptions?.instrument?.instanceDecorator,
+            });
             const instanceLoader = new instance_loader_1.InstanceLoader(container, injector, graphInspector, logger);
             return new lazy_module_loader_1.LazyModuleLoader(scanner, instanceLoader, moduleCompiler, container.getModules(), moduleOverrides);
         };

package/injector/module-ref.js

@@ -18,7 +18,10 @@ class ModuleRef extends abstract_instance_resolver_1.AbstractInstanceResolver {
     constructor(container) {
         super();
         this.container = container;
-        this.injector = new injector_1.Injector();
+        this.injector = new injector_1.Injector({
+            preview: container.contextOptions?.preview,
+            instanceDecorator: container.contextOptions?.instrument?.instanceDecorator,
+        });
     }
     introspect(token) {
         const { wrapperRef } = this.instanceLinksHost.get(token);

package/injector/module.d.ts

@@ -65,7 +65,7 @@ export declare class Module {
     replace(toReplace: InjectionToken, options: any): void;
     hasProvider(token: InjectionToken): boolean;
     hasInjectable(token: InjectionToken): boolean;
-    getProviderByKey<T = any>(name: InjectionToken): InstanceWrapper<T>;
+    getProviderByKey<T = any>(name: InjectionToken<T>): InstanceWrapper<T>;
     getProviderById<T = any>(id: string): InstanceWrapper<T> | undefined;
     getControllerById<T = any>(id: string): InstanceWrapper<T> | undefined;
     getInjectableById<T = any>(id: string): InstanceWrapper<T> | undefined;

package/injector/module.js

@@ -239,11 +239,12 @@ class Module {
     }
     addCustomValue(provider, collection, enhancerSubtype) {
         const { useValue: value, provide: providerToken } = provider;
+        const instanceDecorator = this.container.contextOptions?.instrument?.instanceDecorator;
         collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
             token: providerToken,
             name: providerToken?.name || providerToken,
             metatype: null,
-            instance: value,
+            instance: instanceDecorator ? instanceDecorator(value) : value,
             isResolved: true,
             async: value instanceof Promise,
             host: this,

package/injector/modules-container.d.ts

@@ -1,6 +1,27 @@
+import { Observable } from 'rxjs';
 import { Module } from './module';
 export declare class ModulesContainer extends Map<string, Module> {
     private readonly _applicationId;
+    private readonly _rpcTargetRegistry$;
+    /**
+     * Unique identifier of the application instance.
+     */
     get applicationId(): string;
+    /**
+     * Retrieves a module by its identifier.
+     * @param id The identifier of the module to retrieve.
+     * @returns The module instance if found, otherwise undefined.
+     */
     getById(id: string): Module | undefined;
+    /**
+     * Returns the RPC target registry as an observable.
+     * This registry contains all RPC targets registered in the application.
+     * @returns An observable that emits the RPC target registry.
+     */
+    getRpcTargetRegistry<T>(): Observable<T>;
+    /**
+     * Adds an RPC target to the registry.
+     * @param target The RPC target to add.
+     */
+    addRpcTarget<T>(target: T): void;
 }

package/injector/modules-container.js

@@ -1,17 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModulesContainer = void 0;
+const rxjs_1 = require("rxjs");
 const uid_1 = require("uid");
 class ModulesContainer extends Map {
     constructor() {
         super(...arguments);
         this._applicationId = (0, uid_1.uid)(21);
+        this._rpcTargetRegistry$ = new rxjs_1.ReplaySubject();
     }
+    /**
+     * Unique identifier of the application instance.
+     */
     get applicationId() {
         return this._applicationId;
     }
+    /**
+     * Retrieves a module by its identifier.
+     * @param id The identifier of the module to retrieve.
+     * @returns The module instance if found, otherwise undefined.
+     */
     getById(id) {
         return Array.from(this.values()).find(moduleRef => moduleRef.id === id);
     }
+    /**
+     * Returns the RPC target registry as an observable.
+     * This registry contains all RPC targets registered in the application.
+     * @returns An observable that emits the RPC target registry.
+     */
+    getRpcTargetRegistry() {
+        return this._rpcTargetRegistry$.asObservable();
+    }
+    /**
+     * Adds an RPC target to the registry.
+     * @param target The RPC target to add.
+     */
+    addRpcTarget(target) {
+        this._rpcTargetRegistry$.next(target);
+    }
 }
 exports.ModulesContainer = ModulesContainer;

package/nest-application.js

@@ -37,7 +37,10 @@ class NestApplication extends nest_application_context_1.NestApplicationContext
         this.isListening = false;
         this.selectContextModule();
         this.registerHttpServer();
-        this.injector = new injector_1.Injector({ preview: this.appOptions.preview });
+        this.injector = new injector_1.Injector({
+            preview: this.appOptions.preview,
+            instanceDecorator: appOptions.instrument?.instanceDecorator,
+        });
         this.middlewareModule = new middleware_module_1.MiddlewareModule();
         this.routesResolver = new routes_resolver_1.RoutesResolver(this.container, this.config, this.injector, this.graphInspector);
     }

package/nest-factory.js

@@ -94,7 +94,10 @@ class NestFactoryStatic {
         uuid_factory_1.UuidFactory.mode = options.snapshot
             ? uuid_factory_1.UuidFactoryMode.Deterministic
             : uuid_factory_1.UuidFactoryMode.Random;
-        const injector = new injector_1.Injector({ preview: options.preview });
+        const injector = new injector_1.Injector({
+            preview: options.preview,
+            instanceDecorator: options.instrument?.instanceDecorator,
+        });
         const instanceLoader = new instance_loader_1.InstanceLoader(container, injector, graphInspector);
         const metadataScanner = new metadata_scanner_1.MetadataScanner();
         const dependenciesScanner = new scanner_1.DependenciesScanner(container, metadataScanner, graphInspector, config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "11.1.3",
+  "version": "11.1.4",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "uid": "2.0.2"
   },
   "devDependencies": {
-    "@nestjs/common": "11.1.3"
+    "@nestjs/common": "11.1.4"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",

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/index.d.ts

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

package/repl/native-functions/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./help-repl-fn"), exports);
-tslib_1.__exportStar(require("./get-relp-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);

package/router/router-explorer.d.ts

@@ -34,7 +34,7 @@ export declare class RouterExplorer {
     private readonly logger;
     private readonly exceptionFiltersCache;
     constructor(metadataScanner: MetadataScanner, container: NestContainer, injector: Injector, routerProxy: RouterProxy, exceptionsFilter: ExceptionsFilter, config: ApplicationConfig, routePathFactory: RoutePathFactory, graphInspector: GraphInspector);
-    explore<T extends HttpServer = any>(instanceWrapper: InstanceWrapper, moduleKey: string, applicationRef: T, host: string | RegExp | Array<string | RegExp>, routePathMetadata: RoutePathMetadata): void;
+    explore<T extends HttpServer = any>(instanceWrapper: InstanceWrapper, moduleKey: string, httpAdapterRef: T, host: string | RegExp | Array<string | RegExp>, routePathMetadata: RoutePathMetadata): void;
     extractRouterPath(metatype: Type<Controller>): string[];
     applyPathsToRouterProxy<T extends HttpServer>(router: T, routeDefinitions: RouteDefinition[], instanceWrapper: InstanceWrapper, moduleKey: string, routePathMetadata: RoutePathMetadata, host: string | RegExp | Array<string | RegExp>): void;
     private applyCallbackToRouter;

package/router/router-explorer.js

@@ -43,10 +43,10 @@ class RouterExplorer {
         const interceptorsConsumer = new interceptors_1.InterceptorsConsumer();
         this.executionContextCreator = new router_execution_context_1.RouterExecutionContext(routeParamsFactory, pipesContextCreator, pipesConsumer, guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, container.getHttpAdapterRef());
     }
-    explore(instanceWrapper, moduleKey, applicationRef, host, routePathMetadata) {
+    explore(instanceWrapper, moduleKey, httpAdapterRef, host, routePathMetadata) {
         const { instance } = instanceWrapper;
         const routerPaths = this.pathsExplorer.scanForPaths(instance);
-        this.applyPathsToRouterProxy(applicationRef, routerPaths, instanceWrapper, moduleKey, routePathMetadata, host);
+        this.applyPathsToRouterProxy(httpAdapterRef, routerPaths, instanceWrapper, moduleKey, routePathMetadata, host);
     }
     extractRouterPath(metatype) {
         const path = Reflect.getMetadata(constants_1.PATH_METADATA, metatype);
@@ -105,7 +105,17 @@ class RouterExplorer {
                 const normalizedPath = router.normalizePath
                     ? router.normalizePath(path)
                     : path;
-                routerMethodRef(normalizedPath, routeHandler);
+                const httpAdapter = this.container.getHttpAdapterRef();
+                const onRouteTriggered = httpAdapter.getOnRouteTriggered?.();
+                if (onRouteTriggered) {
+                    routerMethodRef(normalizedPath, (...args) => {
+                        onRouteTriggered(requestMethod, path);
+                        return routeHandler(...args);
+                    });
+                }
+                else {
+                    routerMethodRef(normalizedPath, routeHandler);
+                }
                 this.graphInspector.insertEntrypointDefinition(entrypointDefinition, instanceWrapper.id);
             });
             const pathsToLog = this.routePathFactory.create({

package/router/utils/flatten-route-paths.util.js

@@ -11,7 +11,7 @@ function flattenRoutePaths(routes) {
         if (item.children) {
             const childrenRef = item.children;
             childrenRef.forEach(child => {
-                if (!(0, shared_utils_1.isString)(child) && child.path) {
+                if (!(0, shared_utils_1.isString)(child) && (0, shared_utils_1.isString)(child.path)) {
                     child.path = (0, shared_utils_1.normalizePath)((0, shared_utils_1.normalizePath)(item.path) + (0, shared_utils_1.normalizePath)(child.path));
                 }
                 else {