Initial commit - Event Planner application

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

@@ -0,0 +1,3 @@
+export * from './params-token-factory';
+export * from './pipes-consumer';
+export * from './pipes-context-creator';

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

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

node_modules/@nestjs/core/pipes/params-token-factory.d.ts

@@ -0,0 +1,5 @@
+import { Paramtype } from '@nestjs/common';
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
+export declare class ParamsTokenFactory {
+    exchangeEnumForString(type: RouteParamtypes): Paramtype;
+}

node_modules/@nestjs/core/pipes/params-token-factory.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamsTokenFactory = void 0;
+const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
+class ParamsTokenFactory {
+    exchangeEnumForString(type) {
+        switch (type) {
+            case route_paramtypes_enum_1.RouteParamtypes.BODY:
+                return 'body';
+            case route_paramtypes_enum_1.RouteParamtypes.PARAM:
+                return 'param';
+            case route_paramtypes_enum_1.RouteParamtypes.QUERY:
+                return 'query';
+            default:
+                return 'custom';
+        }
+    }
+}
+exports.ParamsTokenFactory = ParamsTokenFactory;

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

@@ -0,0 +1,10 @@
+import { ArgumentMetadata, PipeTransform } from '@nestjs/common/interfaces';
+export declare class PipesConsumer {
+    private readonly paramsTokenFactory;
+    apply<TInput = unknown>(value: TInput, { metatype, type, data }: ArgumentMetadata, pipes: PipeTransform[]): Promise<any>;
+    applyPipes<TInput = unknown>(value: TInput, { metatype, type, data }: {
+        metatype: any;
+        type?: any;
+        data?: any;
+    }, transforms: PipeTransform[]): Promise<any>;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipesConsumer = void 0;
+const params_token_factory_1 = require("./params-token-factory");
+class PipesConsumer {
+    constructor() {
+        this.paramsTokenFactory = new params_token_factory_1.ParamsTokenFactory();
+    }
+    async apply(value, { metatype, type, data }, pipes) {
+        const token = this.paramsTokenFactory.exchangeEnumForString(type);
+        return this.applyPipes(value, { metatype, type: token, data }, pipes);
+    }
+    async applyPipes(value, { metatype, type, data }, transforms) {
+        return transforms.reduce(async (deferredValue, pipe) => {
+            const val = await deferredValue;
+            const result = pipe.transform(val, { metatype, type, data });
+            return result;
+        }, Promise.resolve(value));
+    }
+}
+exports.PipesConsumer = PipesConsumer;

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

@@ -0,0 +1,17 @@
+import { Controller, PipeTransform, 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 PipesContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: NestContainer, config?: ApplicationConfig | undefined);
+    create(instance: Controller, callback: (...args: unknown[]) => unknown, moduleKey: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): PipeTransform[];
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
+    getPipeInstance(pipe: Function | PipeTransform, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): PipeTransform | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+    setModuleContext(context: string): void;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipesContextCreator = 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 PipesContextCreator extends context_creator_1.ContextCreator {
+    constructor(container, config) {
+        super();
+        this.container = container;
+        this.config = config;
+    }
+    create(instance, callback, moduleKey, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = moduleKey;
+        return this.createContext(instance, callback, constants_1.PIPES_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((pipe) => pipe && (pipe.name || pipe.transform))
+            .map(pipe => this.getPipeInstance(pipe, contextId, inquirerId))
+            .filter(pipe => !!pipe && pipe.transform && (0, shared_utils_1.isFunction)(pipe.transform))
+            .toArray();
+    }
+    getPipeInstance(pipe, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const isObject = !!pipe.transform;
+        if (isObject) {
+            return pipe;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(pipe);
+        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 globalPipes = this.config.getGlobalPipes();
+        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+            return globalPipes;
+        }
+        const scopedPipeWrappers = this.config.getGlobalRequestPipes();
+        const scopedPipes = (0, iterare_1.iterate)(scopedPipeWrappers)
+            .map(wrapper => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
+            .filter(host => !!host)
+            .map(host => host.instance)
+            .toArray();
+        return globalPipes.concat(scopedPipes);
+    }
+    setModuleContext(context) {
+        this.moduleContext = context;
+    }
+}
+exports.PipesContextCreator = PipesContextCreator;