Initial commit - Event Planner application

node_modules/@nestjs/core/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interceptors-consumer';
+export * from './interceptors-context-creator';

node_modules/@nestjs/core/interceptors/index.js

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

node_modules/@nestjs/core/interceptors/interceptors-consumer.d.ts

@@ -0,0 +1,9 @@
+import { NestInterceptor } from '@nestjs/common';
+import { ContextType, Controller } from '@nestjs/common/interfaces';
+import { Observable } from 'rxjs';
+import { ExecutionContextHost } from '../helpers/execution-context-host';
+export declare class InterceptorsConsumer {
+    intercept<TContext extends string = ContextType>(interceptors: NestInterceptor[], args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown, next: () => Promise<unknown>, type?: TContext): Promise<unknown>;
+    createContext(args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown): ExecutionContextHost;
+    transformDeferred(next: () => Promise<any>): Observable<any>;
+}

node_modules/@nestjs/core/interceptors/interceptors-consumer.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterceptorsConsumer = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const async_hooks_1 = require("async_hooks");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const execution_context_host_1 = require("../helpers/execution-context-host");
+class InterceptorsConsumer {
+    async intercept(interceptors, args, instance, callback, next, type) {
+        if ((0, shared_utils_1.isEmpty)(interceptors)) {
+            return next();
+        }
+        const context = this.createContext(args, instance, callback);
+        context.setType(type);
+        const nextFn = async (i = 0) => {
+            if (i >= interceptors.length) {
+                return (0, rxjs_1.defer)(async_hooks_1.AsyncResource.bind(() => this.transformDeferred(next)));
+            }
+            const handler = {
+                handle: () => (0, rxjs_1.defer)(async_hooks_1.AsyncResource.bind(() => nextFn(i + 1))).pipe((0, operators_1.mergeAll)()),
+            };
+            return interceptors[i].intercept(context, handler);
+        };
+        return (0, rxjs_1.defer)(() => nextFn()).pipe((0, operators_1.mergeAll)());
+    }
+    createContext(args, instance, callback) {
+        return new execution_context_host_1.ExecutionContextHost(args, instance.constructor, callback);
+    }
+    transformDeferred(next) {
+        return (0, rxjs_1.from)(next()).pipe((0, operators_1.switchMap)(res => {
+            const isDeferred = res instanceof Promise || res instanceof rxjs_1.Observable;
+            return isDeferred ? res : Promise.resolve(res);
+        }));
+    }
+}
+exports.InterceptorsConsumer = InterceptorsConsumer;

node_modules/@nestjs/core/interceptors/interceptors-context-creator.d.ts

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

node_modules/@nestjs/core/interceptors/interceptors-context-creator.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterceptorsContextCreator = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const context_creator_1 = require("../helpers/context-creator");
+const constants_2 = require("../injector/constants");
+class InterceptorsContextCreator extends context_creator_1.ContextCreator {
+    constructor(container, config) {
+        super();
+        this.container = container;
+        this.config = config;
+    }
+    create(instance, callback, module, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = module;
+        return this.createContext(instance, callback, constants_1.INTERCEPTORS_METADATA, contextId, inquirerId);
+    }
+    createConcreteContext(metadata, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if ((0, shared_utils_1.isEmpty)(metadata)) {
+            return [];
+        }
+        return (0, iterare_1.iterate)(metadata)
+            .filter(interceptor => interceptor && (interceptor.name || interceptor.intercept))
+            .map(interceptor => this.getInterceptorInstance(interceptor, contextId, inquirerId))
+            .filter((interceptor) => interceptor ? (0, shared_utils_1.isFunction)(interceptor.intercept) : false)
+            .toArray();
+    }
+    getInterceptorInstance(metatype, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const isObject = !!metatype.intercept;
+        if (isObject) {
+            return metatype;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(metatype);
+        if (!instanceWrapper) {
+            return null;
+        }
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        return instanceHost && instanceHost.instance;
+    }
+    getInstanceByMetatype(metatype) {
+        if (!this.moduleContext) {
+            return;
+        }
+        const collection = this.container.getModules();
+        const moduleRef = collection.get(this.moduleContext);
+        if (!moduleRef) {
+            return;
+        }
+        return moduleRef.injectables.get(metatype);
+    }
+    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if (!this.config) {
+            return [];
+        }
+        const globalInterceptors = this.config.getGlobalInterceptors();
+        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+            return globalInterceptors;
+        }
+        const scopedInterceptorWrappers = this.config.getGlobalRequestInterceptors();
+        const scopedInterceptors = (0, iterare_1.iterate)(scopedInterceptorWrappers)
+            .map(wrapper => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
+            .filter(host => !!host)
+            .map(host => host.instance)
+            .toArray();
+        return globalInterceptors.concat(scopedInterceptors);
+    }
+}
+exports.InterceptorsContextCreator = InterceptorsContextCreator;