Initial commit - Event Planner application

node_modules/@nestjs/core/guards/constants.d.ts

@@ -0,0 +1 @@
+export declare const FORBIDDEN_MESSAGE = "Forbidden resource";

node_modules/@nestjs/core/guards/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORBIDDEN_MESSAGE = void 0;
+exports.FORBIDDEN_MESSAGE = 'Forbidden resource';

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

@@ -0,0 +1,9 @@
+import { CanActivate } from '@nestjs/common';
+import { ContextType, Controller } from '@nestjs/common/interfaces';
+import { Observable } from 'rxjs';
+import { ExecutionContextHost } from '../helpers/execution-context-host';
+export declare class GuardsConsumer {
+    tryActivate<TContext extends string = ContextType>(guards: CanActivate[], args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown, type?: TContext): Promise<boolean>;
+    createContext(args: unknown[], instance: Controller, callback: (...args: unknown[]) => unknown): ExecutionContextHost;
+    pickResult(result: boolean | Promise<boolean> | Observable<boolean>): Promise<boolean>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardsConsumer = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const rxjs_1 = require("rxjs");
+const execution_context_host_1 = require("../helpers/execution-context-host");
+class GuardsConsumer {
+    async tryActivate(guards, args, instance, callback, type) {
+        if (!guards || (0, shared_utils_1.isEmpty)(guards)) {
+            return true;
+        }
+        const context = this.createContext(args, instance, callback);
+        context.setType(type);
+        for (const guard of guards) {
+            const result = guard.canActivate(context);
+            if (typeof result === 'boolean') {
+                if (!result) {
+                    return false;
+                }
+                continue;
+            }
+            if (await this.pickResult(result)) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    createContext(args, instance, callback) {
+        return new execution_context_host_1.ExecutionContextHost(args, instance.constructor, callback);
+    }
+    async pickResult(result) {
+        if (result instanceof rxjs_1.Observable) {
+            return (0, rxjs_1.lastValueFrom)(result);
+        }
+        return result;
+    }
+}
+exports.GuardsConsumer = GuardsConsumer;

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

@@ -0,0 +1,17 @@
+import { CanActivate } from '@nestjs/common';
+import { Controller, 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 GuardsContextCreator 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): CanActivate[];
+    createConcreteContext<T extends unknown[], R extends unknown[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
+    getGuardInstance(metatype: Function | CanActivate, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): CanActivate | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+}

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardsContextCreator = 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 GuardsContextCreator 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.GUARDS_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((guard) => guard && (guard.name || guard.canActivate))
+            .map(guard => this.getGuardInstance(guard, contextId, inquirerId))
+            .filter((guard) => !!guard && (0, shared_utils_1.isFunction)(guard.canActivate))
+            .toArray();
+    }
+    getGuardInstance(metatype, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const isObject = !!metatype.canActivate;
+        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;
+        }
+        const injectables = moduleRef.injectables;
+        return injectables.get(metatype);
+    }
+    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if (!this.config) {
+            return [];
+        }
+        const globalGuards = this.config.getGlobalGuards();
+        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+            return globalGuards;
+        }
+        const scopedGuardWrappers = this.config.getGlobalRequestGuards();
+        const scopedGuards = (0, iterare_1.iterate)(scopedGuardWrappers)
+            .map(wrapper => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
+            .filter(host => !!host)
+            .map(host => host.instance)
+            .toArray();
+        return globalGuards.concat(scopedGuards);
+    }
+}
+exports.GuardsContextCreator = GuardsContextCreator;

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

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './guards-consumer';
+export * from './guards-context-creator';

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

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