@depup/nestjs__core 11.1.17-depup.0

package/injector/settlement-signal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * SettlementSignal is used to signal the resolution of a provider/instance.
+ * Calling `complete` or `error` will resolve the promise returned by `asPromise`.
+ * Can be used to detect circular dependencies.
+ */
+export declare class SettlementSignal {
+    private readonly _refs;
+    private readonly settledPromise;
+    private settleFn;
+    private completed;
+    constructor();
+    /**
+     * Resolves the promise returned by `asPromise`.
+     */
+    complete(): void;
+    /**
+     * Rejects the promise returned by `asPromise` with the given error.
+     * @param err Error to reject the promise returned by `asPromise` with.
+     */
+    error(err: unknown): void;
+    /**
+     * Returns a promise that will be resolved when `complete` or `error` is called.
+     * @returns Promise that will be resolved when `complete` or `error` is called.
+     */
+    asPromise(): Promise<unknown>;
+    /**
+     * Inserts a wrapper id that the host of this signal depends on.
+     * @param wrapperId Wrapper id to insert.
+     */
+    insertRef(wrapperId: string): void;
+    /**
+     * Check if relationship is circular.
+     * @param wrapperId Wrapper id to check.
+     * @returns True if relationship is circular, false otherwise.
+     */
+    isCycle(wrapperId: string): boolean;
+}

package/injector/settlement-signal.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettlementSignal = void 0;
+/**
+ * SettlementSignal is used to signal the resolution of a provider/instance.
+ * Calling `complete` or `error` will resolve the promise returned by `asPromise`.
+ * Can be used to detect circular dependencies.
+ */
+class SettlementSignal {
+    constructor() {
+        this._refs = new Set();
+        this.completed = false;
+        this.settledPromise = new Promise(resolve => {
+            this.settleFn = resolve;
+        });
+    }
+    /**
+     * Resolves the promise returned by `asPromise`.
+     */
+    complete() {
+        this.completed = true;
+        this.settleFn();
+    }
+    /**
+     * Rejects the promise returned by `asPromise` with the given error.
+     * @param err Error to reject the promise returned by `asPromise` with.
+     */
+    error(err) {
+        this.completed = true;
+        this.settleFn(err);
+    }
+    /**
+     * Returns a promise that will be resolved when `complete` or `error` is called.
+     * @returns Promise that will be resolved when `complete` or `error` is called.
+     */
+    asPromise() {
+        return this.settledPromise;
+    }
+    /**
+     * Inserts a wrapper id that the host of this signal depends on.
+     * @param wrapperId Wrapper id to insert.
+     */
+    insertRef(wrapperId) {
+        this._refs.add(wrapperId);
+    }
+    /**
+     * Check if relationship is circular.
+     * @param wrapperId Wrapper id to check.
+     * @returns True if relationship is circular, false otherwise.
+     */
+    isCycle(wrapperId) {
+        return !this.completed && this._refs.has(wrapperId);
+    }
+}
+exports.SettlementSignal = SettlementSignal;

package/injector/topology-tree/topology-tree.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '../module';
+export declare class TopologyTree {
+    private root;
+    private links;
+    constructor(moduleRef: Module);
+    walk(callback: (value: Module, depth: number) => void): void;
+    private traverseAndMapToTree;
+}

package/injector/topology-tree/topology-tree.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyTree = void 0;
+const tree_node_1 = require("./tree-node");
+class TopologyTree {
+    constructor(moduleRef) {
+        this.links = new Map();
+        this.root = new tree_node_1.TreeNode({
+            value: moduleRef,
+            parent: null,
+        });
+        this.links.set(moduleRef, this.root);
+        this.traverseAndMapToTree(this.root);
+    }
+    walk(callback) {
+        function walkNode(node, depth = 1) {
+            callback(node.value, depth);
+            node.children.forEach(child => walkNode(child, depth + 1));
+        }
+        walkNode(this.root);
+    }
+    traverseAndMapToTree(node, depth = 1) {
+        if (!node.value.imports) {
+            return;
+        }
+        node.value.imports.forEach(child => {
+            if (!child) {
+                return;
+            }
+            if (this.links.has(child)) {
+                const existingSubtree = this.links.get(child);
+                if (node.hasCycleWith(child)) {
+                    return;
+                }
+                const existingDepth = existingSubtree.getDepth();
+                if (existingDepth < depth) {
+                    existingSubtree.relink(node);
+                }
+                return;
+            }
+            const childNode = new tree_node_1.TreeNode({
+                value: child,
+                parent: node,
+            });
+            node.addChild(childNode);
+            this.links.set(child, childNode);
+            this.traverseAndMapToTree(childNode, depth + 1);
+        });
+    }
+}
+exports.TopologyTree = TopologyTree;

package/injector/topology-tree/tree-node.d.ts

@@ -0,0 +1,14 @@
+export declare class TreeNode<T> {
+    readonly value: T;
+    readonly children: Set<TreeNode<T>>;
+    private parent;
+    constructor({ value, parent }: {
+        value: T;
+        parent: TreeNode<T> | null;
+    });
+    addChild(child: TreeNode<T>): void;
+    removeChild(child: TreeNode<T>): void;
+    relink(parent: TreeNode<T>): void;
+    getDepth(): number;
+    hasCycleWith(target: T): boolean;
+}

package/injector/topology-tree/tree-node.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeNode = void 0;
+class TreeNode {
+    constructor({ value, parent }) {
+        this.children = new Set();
+        this.value = value;
+        this.parent = parent;
+    }
+    addChild(child) {
+        this.children.add(child);
+    }
+    removeChild(child) {
+        this.children.delete(child);
+    }
+    relink(parent) {
+        this.parent?.removeChild(this);
+        this.parent = parent;
+        this.parent.addChild(this);
+    }
+    getDepth() {
+        const visited = new Set();
+        let depth = 0;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let current = this;
+        while (current) {
+            depth++;
+            current = current.parent;
+            // Stop on cycle
+            if (visited.has(current)) {
+                return -1;
+            }
+            visited.add(current);
+        }
+        return depth;
+    }
+    hasCycleWith(target) {
+        const visited = new Set();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let current = this;
+        while (current) {
+            if (current.value === target) {
+                return true;
+            }
+            current = current.parent;
+            if (visited.has(current)) {
+                return false;
+            }
+            visited.add(current);
+        }
+        return false;
+    }
+}
+exports.TreeNode = TreeNode;

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

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

package/inspector/deterministic-uuid-registry.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeterministicUuidRegistry = void 0;
+class DeterministicUuidRegistry {
+    static get(str, inc = 0) {
+        const id = inc ? this.hashCode(`${str}_${inc}`) : this.hashCode(str);
+        if (this.registry.has(id)) {
+            return this.get(str, inc + 1);
+        }
+        this.registry.set(id, true);
+        return id;
+    }
+    static clear() {
+        this.registry.clear();
+    }
+    static hashCode(s) {
+        let h = 0;
+        for (let i = 0; i < s.length; i++)
+            h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+        return h.toString();
+    }
+}
+exports.DeterministicUuidRegistry = DeterministicUuidRegistry;
+DeterministicUuidRegistry.registry = new Map();

package/inspector/graph-inspector.d.ts

@@ -0,0 +1,26 @@
+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;
+    registerPartial(error: unknown): 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,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphInspector = void 0;
+const unknown_dependencies_exception_1 = require("../errors/exceptions/unknown-dependencies.exception");
+const deterministic_uuid_registry_1 = require("./deterministic-uuid-registry");
+const partial_graph_host_1 = require("./partial-graph.host");
+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();
+    }
+    registerPartial(error) {
+        this.graph.status = 'partial';
+        if (error instanceof unknown_dependencies_exception_1.UnknownDependenciesException) {
+            this.graph.metadata = {
+                cause: {
+                    type: 'unknown-dependencies',
+                    context: error.context,
+                    moduleId: error.moduleRef?.id,
+                    nodeId: error.metadata?.id,
+                },
+            };
+        }
+        else {
+            this.graph.metadata = {
+                cause: {
+                    type: 'unknown',
+                    error,
+                },
+            };
+        }
+        partial_graph_host_1.PartialGraphHost.register(this.graph);
+    }
+    inspectInstanceWrapper(source, moduleRef) {
+        const ctorMetadata = source.getCtorMetadata();
+        ctorMetadata?.forEach((target, index) => this.insertClassToClassEdge(source, target, moduleRef, index, 'constructor'));
+        const propertiesMetadata = source.getPropertiesMetadata();
+        propertiesMetadata?.forEach(({ key, wrapper: target }) => this.insertClassToClassEdge(source, target, moduleRef, key, 'property'));
+    }
+    insertEnhancerMetadataCache(entry) {
+        this.enhancersMetadataCache.push(entry);
+    }
+    insertOrphanedEnhancer(entry) {
+        this.graph.insertOrphanedEnhancer({
+            ...entry,
+            ref: entry.ref?.constructor?.name ?? 'Object',
+        });
+    }
+    insertAttachedEnhancer(wrapper) {
+        const existingNode = this.graph.getNodeById(wrapper.id);
+        existingNode.metadata.global = true;
+        this.graph.insertAttachedEnhancer(existingNode.id);
+    }
+    insertEntrypointDefinition(definition, parentId) {
+        definition = {
+            ...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,
+                initTime: wrapper.initTime,
+            },
+        });
+    }
+    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) {
+        const moduleRef = this.container.getModuleByKey(entry.moduleToken);
+        const sourceInstanceWrapper = moduleRef.controllers.get(entry.classRef) ??
+            moduleRef.providers.get(entry.classRef);
+        const existingSourceNode = this.graph.getNodeById(sourceInstanceWrapper.id);
+        const enhancers = existingSourceNode.metadata.enhancers ?? [];
+        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 = entry.enhancerRef.constructor?.name ??
+                entry.enhancerRef.name;
+            enhancers.push({
+                name,
+                methodKey: entry.methodKey,
+                subtype: entry.subtype,
+            });
+        }
+        existingSourceNode.metadata.enhancers = enhancers;
+    }
+    insertClassToClassEdge(source, target, moduleRef, keyOrIndex, injectionType) {
+        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: target.host?.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/index.d.ts

@@ -0,0 +1,4 @@
+export * from './graph-inspector';
+export * from './initialize-on-preview.allowlist';
+export * from './partial-graph.host';
+export * from './serialized-graph';

package/inspector/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./graph-inspector"), exports);
+tslib_1.__exportStar(require("./initialize-on-preview.allowlist"), exports);
+tslib_1.__exportStar(require("./partial-graph.host"), exports);
+tslib_1.__exportStar(require("./serialized-graph"), exports);

package/inspector/initialize-on-preview.allowlist.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@nestjs/common';
+export declare class InitializeOnPreviewAllowlist {
+    private static readonly allowlist;
+    static add(type: Type): void;
+    static has(type: Type): boolean;
+}

package/inspector/initialize-on-preview.allowlist.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializeOnPreviewAllowlist = void 0;
+class InitializeOnPreviewAllowlist {
+    static add(type) {
+        this.allowlist.set(type, true);
+    }
+    static has(type) {
+        return this.allowlist.has(type);
+    }
+}
+exports.InitializeOnPreviewAllowlist = InitializeOnPreviewAllowlist;
+InitializeOnPreviewAllowlist.allowlist = new WeakMap();

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

@@ -0,0 +1,28 @@
+import { InjectionToken } from '@nestjs/common';
+type CommonEdgeMetadata = {
+    sourceModuleName: string;
+    targetModuleName: string;
+};
+type ModuleToModuleEdgeMetadata = {
+    type: 'module-to-module';
+} & CommonEdgeMetadata;
+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 type HttpEntrypointMetadata = {
+    path: string;
+    requestMethod: keyof typeof RequestMethod;
+    methodVersion?: VersionValue;
+    controllerVersion?: VersionValue;
+};
+export type MiddlewareEntrypointMetadata = {
+    path: string;
+    requestMethod: keyof typeof RequestMethod;
+    version?: VersionValue;
+};
+export 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,48 @@
+import { InjectionToken, Scope } from '@nestjs/common';
+import { EnhancerSubtype } from '@nestjs/common/constants';
+export type ModuleNode = {
+    metadata: {
+        type: 'module';
+        global: boolean;
+        dynamic: boolean;
+        internal: boolean;
+    };
+};
+export 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;
+        initTime: number;
+        /**
+         * 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 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/interfaces/serialized-graph-json.interface.d.ts

@@ -0,0 +1,14 @@
+import { SerializedGraphStatus } from '../serialized-graph';
+import { Edge } from './edge.interface';
+import { Entrypoint } from './entrypoint.interface';
+import { Extras } from './extras.interface';
+import { Node } from './node.interface';
+import { SerializedGraphMetadata } from './serialized-graph-metadata.interface';
+export interface SerializedGraphJson {
+    nodes: Record<string, Node>;
+    edges: Record<string, Edge>;
+    entrypoints: Record<string, Entrypoint<unknown>[]>;
+    extras: Extras;
+    status?: SerializedGraphStatus;
+    metadata?: SerializedGraphMetadata;
+}

package/inspector/interfaces/serialized-graph-json.interface.js

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