@nestjs/core 9.2.1 → 9.3.0-beta.2

package/injector/module.js

@@ -9,6 +9,7 @@ const exceptions_1 = require("../errors/exceptions");
 const context_id_factory_1 = require("../helpers/context-id-factory");
 const get_class_scope_1 = require("../helpers/get-class-scope");
 const is_durable_1 = require("../helpers/is-durable");
+const deterministic_uuid_registry_1 = require("../inspector/deterministic-uuid-registry");
 const constants_1 = require("./constants");
 const instance_wrapper_1 = require("./instance-wrapper");
 const module_ref_1 = require("./module-ref");
@@ -23,8 +24,9 @@ class Module {
         this._controllers = new Map();
         this._exports = new Set();
         this._distance = 0;
+        this._isGlobal = false;
         this.addCoreProviders();
-        this._id = (0, random_string_generator_util_1.randomStringGenerator)();
+        this._id = this.generateUuid();
     }
     get id() {
         return this._id;
@@ -35,6 +37,15 @@ class Module {
     set token(token) {
         this._token = token;
     }
+    get name() {
+        return this.metatype.name;
+    }
+    get isGlobal() {
+        return this._isGlobal;
+    }
+    set isGlobal(global) {
+        this._isGlobal = global;
+    }
     get providers() {
         return this._providers;
     }
@@ -122,7 +133,7 @@ class Module {
             host: this,
         }));
     }
-    addInjectable(injectable, host) {
+    addInjectable(injectable, enhancerSubtype, host) {
         if (this.isCustomProvider(injectable)) {
             return this.addCustomProvider(injectable, this._injectables);
         }
@@ -136,6 +147,7 @@ class Module {
                 isResolved: false,
                 scope: (0, get_class_scope_1.getClassScope)(injectable),
                 durable: (0, is_durable_1.isDurable)(injectable),
+                subtype: enhancerSubtype,
                 host: this,
             });
             this._injectables.set(injectable, instanceWrapper);
@@ -144,10 +156,11 @@ class Module {
             const hostWrapper = this._controllers.get(host) || this._providers.get(host);
             hostWrapper && hostWrapper.addEnhancerMetadata(instanceWrapper);
         }
+        return instanceWrapper;
     }
-    addProvider(provider) {
+    addProvider(provider, enhancerSubtype) {
         if (this.isCustomProvider(provider)) {
-            return this.addCustomProvider(provider, this._providers);
+            return this.addCustomProvider(provider, this._providers, enhancerSubtype);
         }
         this._providers.set(provider, new instance_wrapper_1.InstanceWrapper({
             token: provider,
@@ -164,18 +177,18 @@ class Module {
     isCustomProvider(provider) {
         return !(0, shared_utils_1.isNil)(provider.provide);
     }
-    addCustomProvider(provider, collection) {
+    addCustomProvider(provider, collection, enhancerSubtype) {
         if (this.isCustomClass(provider)) {
-            this.addCustomClass(provider, collection);
+            this.addCustomClass(provider, collection, enhancerSubtype);
         }
         else if (this.isCustomValue(provider)) {
-            this.addCustomValue(provider, collection);
+            this.addCustomValue(provider, collection, enhancerSubtype);
         }
         else if (this.isCustomFactory(provider)) {
-            this.addCustomFactory(provider, collection);
+            this.addCustomFactory(provider, collection, enhancerSubtype);
         }
         else if (this.isCustomUseExisting(provider)) {
-            this.addCustomUseExisting(provider, collection);
+            this.addCustomUseExisting(provider, collection, enhancerSubtype);
         }
         return provider.provide;
     }
@@ -194,7 +207,7 @@ class Module {
     isDynamicModule(exported) {
         return exported && exported.module;
     }
-    addCustomClass(provider, collection) {
+    addCustomClass(provider, collection, enhancerSubtype) {
         let { scope, durable } = provider;
         const { useClass } = provider;
         if ((0, shared_utils_1.isUndefined)(scope)) {
@@ -212,9 +225,10 @@ class Module {
             scope,
             durable,
             host: this,
+            subtype: enhancerSubtype,
         }));
     }
-    addCustomValue(provider, collection) {
+    addCustomValue(provider, collection, enhancerSubtype) {
         const { useValue: value, provide: providerToken } = provider;
         collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
             token: providerToken,
@@ -224,9 +238,10 @@ class Module {
             isResolved: true,
             async: value instanceof Promise,
             host: this,
+            subtype: enhancerSubtype,
         }));
     }
-    addCustomFactory(provider, collection) {
+    addCustomFactory(provider, collection, enhancerSubtype) {
         const { useFactory: factory, inject, scope, durable, provide: providerToken, } = provider;
         collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
             token: providerToken,
@@ -238,9 +253,10 @@ class Module {
             scope,
             durable,
             host: this,
+            subtype: enhancerSubtype,
         }));
     }
-    addCustomUseExisting(provider, collection) {
+    addCustomUseExisting(provider, collection, enhancerSubtype) {
         const { useExisting, provide: providerToken } = provider;
         collection.set(providerToken, new instance_wrapper_1.InstanceWrapper({
             token: providerToken,
@@ -251,6 +267,7 @@ class Module {
             inject: [useExisting],
             host: this,
             isAlias: true,
+            subtype: enhancerSubtype,
         }));
     }
     addExportedProvider(provider) {
@@ -333,6 +350,18 @@ class Module {
     getProviderByKey(name) {
         return this._providers.get(name);
     }
+    getProviderById(id) {
+        return Array.from(this._providers.values()).find(item => item.id === id);
+    }
+    getControllerById(id) {
+        return Array.from(this._controllers.values()).find(item => item.id === id);
+    }
+    getInjectableById(id) {
+        return Array.from(this._injectables.values()).find(item => item.id === id);
+    }
+    getMiddlewareById(id) {
+        return Array.from(this._middlewares.values()).find(item => item.id === id);
+    }
     getNonAliasProviders() {
         return [...this._providers].filter(([_, wrapper]) => !wrapper.isAlias);
     }
@@ -362,5 +391,13 @@ class Module {
             }
         };
     }
+    generateUuid() {
+        var _a, _b, _c;
+        const UUID_NAMESPACE = 'fb848993-0c82-4b9e-ae95-3c3c1dbe3d6b';
+        const key = (_b = (_a = this.name) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : (_c = this.token) === null || _c === void 0 ? void 0 : _c.toString();
+        return key
+            ? deterministic_uuid_registry_1.DeterministicUuidRegistry.get(key, UUID_NAMESPACE)
+            : (0, random_string_generator_util_1.randomStringGenerator)();
+    }
 }
 exports.Module = Module;

package/injector/modules-container.d.ts

@@ -2,4 +2,5 @@ import { Module } from './module';
 export declare class ModulesContainer extends Map<string, Module> {
     private readonly _applicationId;
     get applicationId(): string;
+    getById(id: string): Module | undefined;
 }

package/injector/modules-container.js

@@ -10,5 +10,8 @@ class ModulesContainer extends Map {
     get applicationId() {
         return this._applicationId;
     }
+    getById(id) {
+        return Array.from(this.values()).find(moduleRef => moduleRef.id === id);
+    }
 }
 exports.ModulesContainer = ModulesContainer;

package/inspector/deterministic-uuid-registry.d.ts

@@ -0,0 +1,5 @@
+export declare class DeterministicUuidRegistry {
+    private static readonly registry;
+    static get(str: string, namespace?: string, inc?: number): any;
+    static clear(): void;
+}

package/inspector/deterministic-uuid-registry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeterministicUuidRegistry = void 0;
+const uuid_1 = require("uuid");
+const DEFAULT_UUID_NAMESPACE = 'efa0df42-88af-474f-9cad-4206a2319f07';
+class DeterministicUuidRegistry {
+    static get(str, namespace = DEFAULT_UUID_NAMESPACE, inc = 0) {
+        const id = inc ? (0, uuid_1.v5)(str + `${inc}`, namespace) : (0, uuid_1.v5)(str, namespace);
+        if (this.registry.has(id)) {
+            return this.get(str, namespace, inc + 1);
+        }
+        this.registry.add(id);
+        return id;
+    }
+    static clear() {
+        this.registry.clear();
+    }
+}
+exports.DeterministicUuidRegistry = DeterministicUuidRegistry;
+DeterministicUuidRegistry.registry = new Set();

package/inspector/graph-inspector.d.ts

@@ -0,0 +1,25 @@
+import { NestContainer } from '../injector/container';
+import { InstanceWrapper } from '../injector/instance-wrapper';
+import { Module } from '../injector/module';
+import { EnhancerMetadataCacheEntry } from './interfaces/enhancer-metadata-cache-entry.interface';
+import { Entrypoint } from './interfaces/entrypoint.interface';
+import { OrphanedEnhancerDefinition } from './interfaces/extras.interface';
+import { Node } from './interfaces/node.interface';
+export declare class GraphInspector {
+    private readonly container;
+    private readonly graph;
+    private readonly enhancersMetadataCache;
+    constructor(container: NestContainer);
+    inspectModules(modules?: Map<string, Module>): void;
+    inspectInstanceWrapper<T = any>(source: InstanceWrapper<T>, moduleRef: Module): void;
+    insertEnhancerMetadataCache(entry: EnhancerMetadataCacheEntry): void;
+    insertOrphanedEnhancer(entry: OrphanedEnhancerDefinition): void;
+    insertAttachedEnhancer(wrapper: InstanceWrapper): void;
+    insertEntrypointDefinition<T>(definition: Entrypoint<T>, parentId: string): void;
+    insertClassNode(moduleRef: Module, wrapper: InstanceWrapper, type: Exclude<Node['metadata']['type'], 'module'>): void;
+    private insertModuleNode;
+    private insertModuleToModuleEdges;
+    private insertEnhancerEdge;
+    private insertClassToClassEdge;
+    private insertClassNodes;
+}

package/inspector/graph-inspector.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphInspector = void 0;
+const deterministic_uuid_registry_1 = require("./deterministic-uuid-registry");
+class GraphInspector {
+    constructor(container) {
+        this.container = container;
+        this.enhancersMetadataCache = new Array();
+        this.graph = container.serializedGraph;
+    }
+    inspectModules(modules = this.container.getModules()) {
+        for (const moduleRef of modules.values()) {
+            this.insertModuleNode(moduleRef);
+            this.insertClassNodes(moduleRef);
+            this.insertModuleToModuleEdges(moduleRef);
+        }
+        this.enhancersMetadataCache.forEach(entry => this.insertEnhancerEdge(entry));
+        deterministic_uuid_registry_1.DeterministicUuidRegistry.clear();
+    }
+    inspectInstanceWrapper(source, moduleRef) {
+        const ctorMetadata = source.getCtorMetadata();
+        ctorMetadata === null || ctorMetadata === void 0 ? void 0 : ctorMetadata.forEach((target, index) => this.insertClassToClassEdge(source, target, moduleRef, index, 'constructor'));
+        const propertiesMetadata = source.getPropertiesMetadata();
+        propertiesMetadata === null || propertiesMetadata === void 0 ? void 0 : propertiesMetadata.forEach(({ key, wrapper: target }) => this.insertClassToClassEdge(source, target, moduleRef, key, 'property'));
+    }
+    insertEnhancerMetadataCache(entry) {
+        this.enhancersMetadataCache.push(entry);
+    }
+    insertOrphanedEnhancer(entry) {
+        var _a, _b, _c;
+        this.graph.insertOrphanedEnhancer(Object.assign(Object.assign({}, entry), { ref: (_c = (_b = (_a = entry.ref) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'Object' }));
+    }
+    insertAttachedEnhancer(wrapper) {
+        const existingNode = this.graph.getNodeById(wrapper.id);
+        existingNode.metadata.global = true;
+        this.graph.insertAttachedEnhancer(existingNode.id);
+    }
+    insertEntrypointDefinition(definition, parentId) {
+        definition = Object.assign(Object.assign({}, definition), { id: `${definition.classNodeId}_${definition.methodName}` });
+        this.graph.insertEntrypoint(definition, parentId);
+    }
+    insertClassNode(moduleRef, wrapper, type) {
+        this.graph.insertNode({
+            id: wrapper.id,
+            label: wrapper.name,
+            parent: moduleRef.id,
+            metadata: {
+                type,
+                internal: wrapper.metatype === moduleRef.metatype,
+                sourceModuleName: moduleRef.name,
+                durable: wrapper.isDependencyTreeDurable(),
+                static: wrapper.isDependencyTreeStatic(),
+                scope: wrapper.scope,
+                transient: wrapper.isTransient,
+                exported: moduleRef.exports.has(wrapper.token),
+                token: wrapper.token,
+                subtype: wrapper.subtype,
+            },
+        });
+    }
+    insertModuleNode(moduleRef) {
+        const dynamicMetadata = this.container.getDynamicMetadataByToken(moduleRef.token);
+        const node = {
+            id: moduleRef.id,
+            label: moduleRef.name,
+            metadata: {
+                type: 'module',
+                global: moduleRef.isGlobal,
+                dynamic: !!dynamicMetadata,
+                internal: moduleRef.name === 'InternalCoreModule',
+            },
+        };
+        this.graph.insertNode(node);
+    }
+    insertModuleToModuleEdges(moduleRef) {
+        for (const targetModuleRef of moduleRef.imports) {
+            this.graph.insertEdge({
+                source: moduleRef.id,
+                target: targetModuleRef.id,
+                metadata: {
+                    type: 'module-to-module',
+                    sourceModuleName: moduleRef.name,
+                    targetModuleName: targetModuleRef.name,
+                },
+            });
+        }
+    }
+    insertEnhancerEdge(entry) {
+        var _a, _b, _c, _d;
+        const moduleRef = this.container.getModuleByKey(entry.moduleToken);
+        const sourceInstanceWrapper = (_a = moduleRef.controllers.get(entry.classRef)) !== null && _a !== void 0 ? _a : moduleRef.providers.get(entry.classRef);
+        const existingSourceNode = this.graph.getNodeById(sourceInstanceWrapper.id);
+        const enhancers = (_b = existingSourceNode.metadata.enhancers) !== null && _b !== void 0 ? _b : [];
+        if (entry.enhancerInstanceWrapper) {
+            this.insertClassToClassEdge(sourceInstanceWrapper, entry.enhancerInstanceWrapper, moduleRef, undefined, 'decorator');
+            enhancers.push({
+                id: entry.enhancerInstanceWrapper.id,
+                methodKey: entry.methodKey,
+                subtype: entry.subtype,
+            });
+        }
+        else {
+            const name = (_d = (_c = entry.enhancerRef.constructor) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : entry.enhancerRef.name;
+            enhancers.push({
+                name,
+                methodKey: entry.methodKey,
+                subtype: entry.subtype,
+            });
+        }
+        existingSourceNode.metadata.enhancers = enhancers;
+    }
+    insertClassToClassEdge(source, target, moduleRef, keyOrIndex, injectionType) {
+        var _a;
+        this.graph.insertEdge({
+            source: source.id,
+            target: target.id,
+            metadata: {
+                type: 'class-to-class',
+                sourceModuleName: moduleRef.name,
+                sourceClassName: source.name,
+                targetClassName: target.name,
+                sourceClassToken: source.token,
+                targetClassToken: target.token,
+                targetModuleName: (_a = target.host) === null || _a === void 0 ? void 0 : _a.name,
+                keyOrIndex,
+                injectionType,
+            },
+        });
+    }
+    insertClassNodes(moduleRef) {
+        moduleRef.providers.forEach(value => this.insertClassNode(moduleRef, value, 'provider'));
+        moduleRef.injectables.forEach(value => this.insertClassNode(moduleRef, value, 'injectable'));
+        moduleRef.controllers.forEach(value => this.insertClassNode(moduleRef, value, 'controller'));
+    }
+}
+exports.GraphInspector = GraphInspector;

package/inspector/interfaces/edge.interface.d.ts

@@ -0,0 +1,28 @@
+import { InjectionToken } from '@nestjs/common';
+declare type CommonEdgeMetadata = {
+    sourceModuleName: string;
+    targetModuleName: string;
+};
+declare type ModuleToModuleEdgeMetadata = {
+    type: 'module-to-module';
+} & CommonEdgeMetadata;
+declare type ClassToClassEdgeMetadata = {
+    type: 'class-to-class';
+    sourceClassName: string;
+    targetClassName: string;
+    sourceClassToken: InjectionToken;
+    targetClassToken: InjectionToken;
+    injectionType: 'constructor' | 'property' | 'decorator';
+    keyOrIndex?: string | number | symbol;
+    /**
+     * If true, indicates that this edge represents an internal providers connection
+     */
+    internal?: boolean;
+} & CommonEdgeMetadata;
+export interface Edge {
+    id: string;
+    source: string;
+    target: string;
+    metadata: ModuleToModuleEdgeMetadata | ClassToClassEdgeMetadata;
+}
+export {};

package/inspector/interfaces/edge.interface.js

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

package/inspector/interfaces/enhancer-metadata-cache-entry.interface.d.ts

@@ -0,0 +1,12 @@
+import { Type } from '@nestjs/common';
+import { EnhancerSubtype } from '@nestjs/common/constants';
+import { InstanceWrapper } from '../../injector/instance-wrapper';
+export interface EnhancerMetadataCacheEntry {
+    targetNodeId?: string;
+    moduleToken: string;
+    classRef: Type;
+    methodKey: string | undefined;
+    enhancerRef?: unknown;
+    enhancerInstanceWrapper?: InstanceWrapper;
+    subtype: EnhancerSubtype;
+}

package/inspector/interfaces/enhancer-metadata-cache-entry.interface.js

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

package/inspector/interfaces/entrypoint.interface.d.ts

@@ -0,0 +1,23 @@
+import { RequestMethod } from '@nestjs/common';
+import { VersionValue } from '@nestjs/common/interfaces';
+export declare type HttpEntrypointMetadata = {
+    path: string;
+    requestMethod: keyof typeof RequestMethod;
+    methodVersion?: VersionValue;
+    controllerVersion?: VersionValue;
+};
+export declare type MiddlewareEntrypointMetadata = {
+    path: string;
+    requestMethod: keyof typeof RequestMethod;
+    version?: VersionValue;
+};
+export declare type Entrypoint<T> = {
+    id?: string;
+    type: string;
+    methodName: string;
+    className: string;
+    classNodeId: string;
+    metadata: {
+        key: string;
+    } & T;
+};

package/inspector/interfaces/entrypoint.interface.js

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

package/inspector/interfaces/extras.interface.d.ts

@@ -0,0 +1,18 @@
+import { EnhancerSubtype } from '@nestjs/common/constants';
+/**
+ * Enhancers attached through APP_PIPE, APP_GUARD, APP_INTERCEPTOR, and APP_FILTER tokens.
+ */
+export interface AttachedEnhancerDefinition {
+    nodeId: string;
+}
+/**
+ * Enhancers registered through "app.useGlobalPipes()", "app.useGlobalGuards()", "app.useGlobalInterceptors()", and "app.useGlobalFilters()" methods.
+ */
+export interface OrphanedEnhancerDefinition {
+    subtype: EnhancerSubtype;
+    ref: unknown;
+}
+export interface Extras {
+    orphanedEnhancers: Array<OrphanedEnhancerDefinition>;
+    attachedEnhancers: Array<AttachedEnhancerDefinition>;
+}

package/inspector/interfaces/extras.interface.js

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

package/inspector/interfaces/node.interface.d.ts

@@ -0,0 +1,47 @@
+import { InjectionToken, Scope } from '@nestjs/common';
+import { EnhancerSubtype } from '@nestjs/common/constants';
+export declare type ModuleNode = {
+    metadata: {
+        type: 'module';
+        global: boolean;
+        dynamic: boolean;
+        internal: boolean;
+    };
+};
+export declare type ClassNode = {
+    parent: string;
+    metadata: {
+        type: 'provider' | 'controller' | 'middleware' | 'injectable';
+        subtype?: EnhancerSubtype;
+        sourceModuleName: string;
+        durable: boolean;
+        static: boolean;
+        transient: boolean;
+        exported: boolean;
+        scope: Scope;
+        token: InjectionToken;
+        /**
+         * Enhancers metadata collection
+         */
+        enhancers?: Array<{
+            id: string;
+            subtype: EnhancerSubtype;
+        } | {
+            name: string;
+            methodKey?: string;
+            subtype: EnhancerSubtype;
+        }>;
+        /**
+         * If true, node is a globally registered enhancer
+         */
+        global?: boolean;
+        /**
+         * If true, indicates that this node represents an internal provider
+         */
+        internal?: boolean;
+    };
+};
+export declare type Node = {
+    id: string;
+    label: string;
+} & (ClassNode | ModuleNode);

package/inspector/interfaces/node.interface.js

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

package/inspector/noop-graph-inspector.d.ts

@@ -0,0 +1,2 @@
+import { GraphInspector } from './graph-inspector';
+export declare const NoopGraphInspector: GraphInspector;

package/inspector/noop-graph-inspector.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopGraphInspector = void 0;
+const graph_inspector_1 = require("./graph-inspector");
+const noop = () => { };
+exports.NoopGraphInspector = new Proxy(graph_inspector_1.GraphInspector.prototype, {
+    get: () => noop,
+});

package/inspector/serialized-graph.d.ts

@@ -0,0 +1,56 @@
+import { InjectionToken } from '@nestjs/common';
+import { Edge } from './interfaces/edge.interface';
+import { Entrypoint } from './interfaces/entrypoint.interface';
+import { Extras, OrphanedEnhancerDefinition } from './interfaces/extras.interface';
+import { Node } from './interfaces/node.interface';
+declare type WithOptionalId<T extends Record<'id', string>> = Omit<T, 'id'> & Partial<Pick<T, 'id'>>;
+export declare class SerializedGraph {
+    private readonly nodes;
+    private readonly edges;
+    private readonly entrypoints;
+    private readonly extras;
+    private static readonly INTERNAL_PROVIDERS;
+    insertNode(nodeDefinition: Node): Node;
+    insertEdge(edgeDefinition: WithOptionalId<Edge>): {
+        id: string;
+        metadata: ({
+            type: "module-to-module";
+        } & {
+            sourceModuleName: string;
+            targetModuleName: string;
+        }) | ({
+            type: "class-to-class";
+            sourceClassName: string;
+            targetClassName: string;
+            sourceClassToken: InjectionToken;
+            targetClassToken: InjectionToken;
+            injectionType: "constructor" | "property" | "decorator";
+            keyOrIndex?: string | number | symbol;
+            internal?: boolean;
+        } & {
+            sourceModuleName: string;
+            targetModuleName: string;
+        });
+        source: string;
+        target: string;
+    };
+    insertEntrypoint<T>(definition: Entrypoint<T>, parentId: string): void;
+    insertOrphanedEnhancer(entry: OrphanedEnhancerDefinition): void;
+    insertAttachedEnhancer(nodeId: string): void;
+    getNodeById(id: string): Node;
+    toJSON(): {
+        nodes: {
+            [k: string]: Node;
+        };
+        edges: {
+            [k: string]: Edge;
+        };
+        entrypoints: {
+            [k: string]: Entrypoint<unknown>[];
+        };
+        extras: Extras;
+    };
+    toString(): string;
+    private generateUuidByEdgeDefinition;
+}
+export {};