@depup/nestjs__core 11.1.17-depup.0

package/router/sse-stream.d.ts

@@ -0,0 +1,43 @@
+import { MessageEvent } from '@nestjs/common/interfaces';
+import { IncomingMessage, OutgoingHttpHeaders } from 'http';
+import { Transform } from 'stream';
+export type AdditionalHeaders = Record<string, string[] | string | number | undefined>;
+interface ReadHeaders {
+    getHeaders?(): AdditionalHeaders;
+}
+interface WriteHeaders {
+    writableEnded?: boolean;
+    writeHead?(statusCode: number, reasonPhrase?: string, headers?: OutgoingHttpHeaders): void;
+    writeHead?(statusCode: number, headers?: OutgoingHttpHeaders): void;
+    flushHeaders?(): void;
+}
+export type WritableHeaderStream = NodeJS.WritableStream & WriteHeaders;
+export type HeaderStream = WritableHeaderStream & ReadHeaders;
+/**
+ * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
+ * Transforms "messages" to W3C event stream content.
+ * See https://html.spec.whatwg.org/multipage/server-sent-events.html
+ * A message is an object with one or more of the following properties:
+ * - data (String or object, which gets turned into JSON)
+ * - type
+ * - id
+ * - retry
+ *
+ * If constructed with a HTTP Request, it will optimise the socket for streaming.
+ * If this stream is piped to an HTTP Response, it will set appropriate headers.
+ */
+export declare class SseStream extends Transform {
+    private lastEventId;
+    constructor(req?: IncomingMessage);
+    pipe<T extends WritableHeaderStream>(destination: T, options?: {
+        additionalHeaders?: AdditionalHeaders;
+        statusCode?: number;
+        end?: boolean;
+    }): T;
+    _transform(message: MessageEvent, encoding: string, callback: (error?: Error | null, data?: any) => void): void;
+    /**
+     * Calls `.write` but handles the drain if needed
+     */
+    writeMessage(message: MessageEvent, cb: (error: Error | null | undefined) => void): void;
+}
+export {};

package/router/sse-stream.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SseStream = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const stream_1 = require("stream");
+function toDataString(data) {
+    if ((0, shared_utils_1.isObject)(data)) {
+        return toDataString(JSON.stringify(data));
+    }
+    return data
+        .split(/\r\n|\r|\n/)
+        .map(line => `data: ${line}\n`)
+        .join('');
+}
+/**
+ * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
+ * Transforms "messages" to W3C event stream content.
+ * See https://html.spec.whatwg.org/multipage/server-sent-events.html
+ * A message is an object with one or more of the following properties:
+ * - data (String or object, which gets turned into JSON)
+ * - type
+ * - id
+ * - retry
+ *
+ * If constructed with a HTTP Request, it will optimise the socket for streaming.
+ * If this stream is piped to an HTTP Response, it will set appropriate headers.
+ */
+class SseStream extends stream_1.Transform {
+    constructor(req) {
+        super({ objectMode: true });
+        this.lastEventId = null;
+        if (req && req.socket) {
+            req.socket.setKeepAlive(true);
+            req.socket.setNoDelay(true);
+            req.socket.setTimeout(0);
+        }
+    }
+    pipe(destination, options) {
+        if (destination.writeHead) {
+            const statusCode = options?.statusCode ?? 200;
+            destination.writeHead(statusCode, {
+                ...options?.additionalHeaders,
+                // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
+                'Content-Type': 'text/event-stream',
+                Connection: 'keep-alive',
+                // Disable cache, even for old browsers and proxies
+                'Cache-Control': 'private, no-cache, no-store, must-revalidate, max-age=0, no-transform',
+                Pragma: 'no-cache',
+                Expire: '0',
+                // NGINX support https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/#x-accel-buffering
+                'X-Accel-Buffering': 'no',
+            });
+            destination.flushHeaders?.();
+        }
+        destination.write('\n');
+        return super.pipe(destination, options);
+    }
+    _transform(message, encoding, callback) {
+        let data = message.type ? `event: ${message.type}\n` : '';
+        data += message.id ? `id: ${message.id}\n` : '';
+        data += message.retry ? `retry: ${message.retry}\n` : '';
+        data += message.data ? toDataString(message.data) : '';
+        data += '\n';
+        this.push(data);
+        callback();
+    }
+    /**
+     * Calls `.write` but handles the drain if needed
+     */
+    writeMessage(message, cb) {
+        if (!message.id) {
+            this.lastEventId++;
+            message.id = this.lastEventId.toString();
+        }
+        if (!this.write(message, 'utf-8')) {
+            this.once('drain', cb);
+        }
+        else {
+            process.nextTick(cb);
+        }
+    }
+}
+exports.SseStream = SseStream;

package/router/utils/exclude-route.util.d.ts

@@ -0,0 +1,4 @@
+import { RequestMethod } from '@nestjs/common';
+import { ExcludeRouteMetadata } from '../interfaces/exclude-route-metadata.interface';
+export declare const isRequestMethodAll: (method: RequestMethod) => boolean;
+export declare function isRouteExcluded(excludedRoutes: ExcludeRouteMetadata[], path: string, requestMethod?: RequestMethod): boolean;

package/router/utils/exclude-route.util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRequestMethodAll = void 0;
+exports.isRouteExcluded = isRouteExcluded;
+const common_1 = require("@nestjs/common");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const isRequestMethodAll = (method) => {
+    return common_1.RequestMethod.ALL === method || method === -1;
+};
+exports.isRequestMethodAll = isRequestMethodAll;
+function isRouteExcluded(excludedRoutes, path, requestMethod) {
+    return excludedRoutes.some(route => {
+        if ((0, exports.isRequestMethodAll)(route.requestMethod) ||
+            route.requestMethod === requestMethod) {
+            return route.pathRegex.exec((0, shared_utils_1.addLeadingSlash)(path));
+        }
+        return false;
+    });
+}

package/router/utils/flatten-route-paths.util.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@nestjs/common';
+import { Routes } from '../interfaces/routes.interface';
+export declare function flattenRoutePaths(routes: Routes): {
+    module: Type;
+    path: string;
+}[];

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenRoutePaths = flattenRoutePaths;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+function flattenRoutePaths(routes) {
+    const result = [];
+    routes.forEach(item => {
+        if (item.module && item.path) {
+            result.push({ module: item.module, path: item.path });
+        }
+        if (item.children) {
+            const childrenRef = item.children;
+            childrenRef.forEach(child => {
+                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 {
+                    result.push({ path: item.path, module: child });
+                }
+            });
+            result.push(...flattenRoutePaths(childrenRef));
+        }
+    });
+    return result;
+}

package/router/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './exclude-route.util';
+export * from './flatten-route-paths.util';

package/router/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./exclude-route.util"), exports);
+tslib_1.__exportStar(require("./flatten-route-paths.util"), exports);

package/scanner.d.ts

@@ -0,0 +1,89 @@
+import { DynamicModule, ForwardReference, Provider } from '@nestjs/common';
+import { EnhancerSubtype } from '@nestjs/common/constants';
+import { ClassProvider, Controller, ExistingProvider, FactoryProvider, Injectable, Type, ValueProvider } from '@nestjs/common/interfaces';
+import { ApplicationConfig } from './application-config';
+import { NestContainer } from './injector/container';
+import { InstanceWrapper } from './injector/instance-wrapper';
+import { Module } from './injector/module';
+import { GraphInspector } from './inspector/graph-inspector';
+import { ModuleDefinition } from './interfaces/module-definition.interface';
+import { ModuleOverride } from './interfaces/module-override.interface';
+import { MetadataScanner } from './metadata-scanner';
+interface ModulesScanParameters {
+    moduleDefinition: ModuleDefinition;
+    scope?: Type<unknown>[];
+    ctxRegistry?: (ForwardReference | DynamicModule | Type<unknown>)[];
+    overrides?: ModuleOverride[];
+    lazy?: boolean;
+}
+export declare class DependenciesScanner {
+    private readonly container;
+    private readonly metadataScanner;
+    private readonly graphInspector;
+    private readonly applicationConfig;
+    private readonly applicationProvidersApplyMap;
+    constructor(container: NestContainer, metadataScanner: MetadataScanner, graphInspector: GraphInspector, applicationConfig?: ApplicationConfig);
+    scan(module: Type<any>, options?: {
+        overrides?: ModuleOverride[];
+    }): Promise<void>;
+    scanForModules({ moduleDefinition, lazy, scope, ctxRegistry, overrides, }: ModulesScanParameters): Promise<Module[]>;
+    insertModule(moduleDefinition: any, scope: Type<unknown>[]): Promise<{
+        moduleRef: Module;
+        inserted: boolean;
+    } | undefined>;
+    scanModulesForDependencies(modules?: Map<string, Module>): Promise<void>;
+    reflectImports(module: Type<unknown>, token: string, context: string): Promise<void>;
+    reflectProviders(module: Type<any>, token: string): void;
+    reflectControllers(module: Type<any>, token: string): void;
+    reflectDynamicMetadata(cls: Type<Injectable>, token: string): void;
+    reflectExports(module: Type<unknown>, token: string): void;
+    reflectInjectables(component: Type<Injectable>, token: string, metadataKey: string): void;
+    reflectParamInjectables(component: Type<Injectable>, token: string, metadataKey: string): void;
+    reflectKeyMetadata(component: Type<Injectable>, key: string, methodKey: string): {
+        methodKey: string;
+        metadata: any;
+    } | undefined;
+    calculateModulesDistance(): void;
+    insertImport(related: any, token: string, context: string): Promise<void>;
+    isCustomProvider(provider: Provider): provider is ClassProvider | ValueProvider | FactoryProvider | ExistingProvider;
+    insertProvider(provider: Provider, token: string): string | symbol | Function | InstanceWrapper<unknown> | undefined;
+    insertInjectable(injectable: Type<Injectable> | object, token: string, host: Type<Injectable>, subtype: EnhancerSubtype, methodKey?: string): InstanceWrapper<any> | undefined;
+    insertExportedProviderOrModule(toExport: ForwardReference | DynamicModule | Type<unknown>, token: string): void;
+    insertController(controller: Type<Controller>, token: string): void;
+    private insertOrOverrideModule;
+    private getOverrideModuleByModule;
+    private overrideModule;
+    reflectMetadata<T = any>(metadataKey: string, metatype: Type<any>): T[];
+    registerCoreModule(overrides?: ModuleOverride[]): Promise<void>;
+    /**
+     * Add either request or transient globally scoped enhancers
+     * to all controllers metadata storage
+     */
+    addScopedEnhancersMetadata(): void;
+    applyApplicationProviders(): void;
+    getApplyProvidersMap(): {
+        [type: string]: Function;
+    };
+    getApplyRequestProvidersMap(): {
+        [type: string]: Function;
+    };
+    isDynamicModule(module: Type<any> | DynamicModule): module is DynamicModule;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Injectable()` decorator.
+     */
+    private isInjectable;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Controller()` decorator.
+     */
+    private isController;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Catch()` decorator.
+     */
+    private isExceptionFilter;
+    private isForwardReference;
+    private isRequestOrTransient;
+}
+export {};