@opra/nestjs 0.33.13 → 1.0.0-alpha.10

package/esm/opra-nestjs-adapter.js

@@ -0,0 +1,156 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Controller, Delete, Get, Head, Next, Options, Patch, Post, Put, Req, Res, Search, UseFilters, } from '@nestjs/common';
+import { ApiDocument, HTTP_CONTROLLER_METADATA, HttpApi, isConstructor, NotFoundError, } from '@opra/common';
+import { HttpAdapter } from '@opra/core';
+import nodePath from 'path';
+import { asMutable } from 'ts-gems';
+import { Public } from './decorators/public.decorator';
+import { OpraExceptionFilter } from './services/opra-exception-filter.js';
+export const kHandler = Symbol.for('kHandler');
+export class OpraNestAdapter extends HttpAdapter {
+    constructor(init, options) {
+        super((function () {
+            const document = new ApiDocument();
+            document.api = new HttpApi(document);
+            return document;
+        })(), options);
+        this.nestControllers = [];
+        this.options = options;
+        let basePath = options?.basePath || '/';
+        if (!basePath.startsWith('/'))
+            basePath = '/' + basePath;
+        this._addRootController(basePath);
+        if (init.controllers)
+            init.controllers.forEach(c => this._addToNestControllers(c, basePath));
+    }
+    async close() {
+        //
+    }
+    _addRootController(basePath) {
+        const _this = this;
+        let RootController = class RootController {
+            schema(_req, next) {
+                _this[kHandler].sendDocumentSchema(_req.opraContext).catch(next);
+            }
+        };
+        __decorate([
+            Get('/\\$schema'),
+            __param(0, Req()),
+            __param(1, Next()),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object, Function]),
+            __metadata("design:returntype", void 0)
+        ], RootController.prototype, "schema", null);
+        RootController = __decorate([
+            Controller({
+                path: basePath,
+            })
+        ], RootController);
+        if (this.options?.schemaRouteIsPublic) {
+            Public()(RootController.prototype, 'schema', Object.getOwnPropertyDescriptor(RootController.prototype, 'schema'));
+        }
+        this.nestControllers.push(RootController);
+    }
+    _addToNestControllers(sourceClass, currentPath) {
+        const metadata = Reflect.getMetadata(HTTP_CONTROLLER_METADATA, sourceClass);
+        if (!metadata)
+            return;
+        const newClass = {
+            [sourceClass.name]: class extends sourceClass {
+            },
+        }[sourceClass.name];
+        const newPath = metadata.path ? nodePath.join(currentPath, metadata.path) : currentPath;
+        const adapter = this;
+        /** Inject exception filter */
+        UseFilters(new OpraExceptionFilter(adapter))(newClass);
+        Controller()(newClass);
+        this.nestControllers.push(newClass);
+        if (metadata.operations) {
+            for (const [k, v] of Object.entries(metadata.operations)) {
+                const operationHandler = sourceClass.prototype[k];
+                Object.defineProperty(newClass.prototype, k, {
+                    writable: true,
+                    /** NestJS handler method */
+                    async value(_req) {
+                        const api = adapter.document.api;
+                        const controller = api.findController(sourceClass);
+                        const operation = controller?.operations.get(k);
+                        const context = asMutable(_req.opraContext);
+                        if (!(context && operation && typeof operationHandler === 'function')) {
+                            throw new NotFoundError({
+                                message: `No endpoint found for [${_req.method}]${_req.baseUrl}`,
+                                details: {
+                                    path: _req.baseUrl,
+                                    method: _req.method,
+                                },
+                            });
+                        }
+                        /** Configure the HttpContext */
+                        context.adapter = adapter;
+                        context.document = adapter.document;
+                        context.operation = operation;
+                        context.controller = operation.owner;
+                        context.controllerInstance = this;
+                        context.operationHandler = operationHandler;
+                        /** Handle request */
+                        await adapter[kHandler].handleRequest(context);
+                    },
+                });
+                /** Copy metadata keys from source function to new one */
+                const metadataKeys = Reflect.getOwnMetadataKeys(operationHandler);
+                const newFn = newClass.prototype[k];
+                for (const key of metadataKeys) {
+                    const m = Reflect.getMetadata(key, operationHandler);
+                    Reflect.defineMetadata(key, m, newFn);
+                }
+                Req()(newClass.prototype, k, 0);
+                Res()(newClass.prototype, k, 1);
+                const descriptor = Object.getOwnPropertyDescriptor(newClass.prototype, k);
+                const operationPath = newPath + (v.path || '');
+                switch (v.method || 'GET') {
+                    case 'DELETE':
+                        /** Call @Delete decorator over new property */
+                        Delete(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'GET':
+                        /** Call @Get decorator over new property */
+                        Get(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'HEAD':
+                        /** Call @Head decorator over new property */
+                        Head(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'OPTIONS':
+                        /** Call @Options decorator over new property */
+                        Options(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'PATCH':
+                        /** Call @Patch decorator over new property */
+                        Patch(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'POST':
+                        /** Call @Post decorator over new property */
+                        Post(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'PUT':
+                        /** Call @Put decorator over new property */
+                        Put(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'SEARCH':
+                        /** Call @Search decorator over new property */
+                        Search(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        if (metadata.controllers) {
+            for (const child of metadata.controllers) {
+                if (!isConstructor(child))
+                    throw new TypeError('Controllers should be injectable a class');
+                this._addToNestControllers(child, newPath);
+            }
+        }
+    }
+}

package/esm/services/opra-exception-filter.js

@@ -1,14 +1,14 @@
-import { __decorate } from "tslib";
-import { Catch } from '@nestjs/common';
-import { OpraException } from '@opra/common';
-let OpraExceptionFilter = class OpraExceptionFilter {
-    catch(exception) {
-        if (exception instanceof OpraException)
-            return true;
-        throw exception;
+import { HttpOutgoing, wrapException } from '@opra/core';
+export const kHandler = Symbol.for('kHandler');
+export class OpraExceptionFilter {
+    constructor(adapter) {
+        this.adapter = adapter;
     }
-};
-OpraExceptionFilter = __decorate([
-    Catch(OpraException)
-], OpraExceptionFilter);
-export { OpraExceptionFilter };
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const _res = ctx.getResponse();
+        const error = wrapException(exception);
+        const response = HttpOutgoing.from(_res);
+        return this.adapter[kHandler].sendErrorResponse(response, [error]);
+    }
+}

package/esm/services/opra-middleware.js

@@ -0,0 +1,21 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@nestjs/common';
+import { HttpContext, HttpIncoming, HttpOutgoing } from '@opra/core';
+let OpraMiddleware = class OpraMiddleware {
+    use(req, res, next) {
+        const request = HttpIncoming.from(req);
+        const response = HttpOutgoing.from(res);
+        /** Create the HttpContext */
+        req.opraContext = new HttpContext({
+            adapter: {},
+            platform: req.route ? 'express' : 'fastify',
+            request,
+            response,
+        });
+        next();
+    }
+};
+OpraMiddleware = __decorate([
+    Injectable()
+], OpraMiddleware);
+export { OpraMiddleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/nestjs",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.10",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
@@ -17,8 +17,9 @@
     "build:esm": "tsc -b tsconfig-build-esm.json",
     "postbuild": "cp README.md package.json ../../LICENSE ../../build/nestjs && cp ../../package.cjs.json ../../build/nestjs/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
+    "format": "prettier . --write --log-level=warn",
+    "test": "jest --passWithNoTests",
+    "cover": "jest --passWithNoTests --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all",
     "clean:test": "ts-cleanup -s test --all",
@@ -26,22 +27,24 @@
     "clean:cover": "rimraf ../../coverage/client"
   },
   "dependencies": {
-    "@opra/common": "^0.33.13",
-    "@opra/core": "^0.33.13",
-    "fast-tokenizer": "^1.2.2",
+    "@opra/common": "^1.0.0-alpha.10",
+    "@opra/core": "^1.0.0-alpha.10",
+    "fast-tokenizer": "^1.3.0",
     "lodash.head": "^4.0.1",
-    "reflect-metadata": "^0.1.14"
+    "reflect-metadata": "^0.2.2"
   },
   "peerDependencies": {
-    "@nestjs/common": "^10.3.1",
-    "@nestjs/core": "^10.3.1"
+    "@nestjs/common": "^10.3.10",
+    "@nestjs/core": "^10.3.10"
   },
   "devDependencies": {
-    "@nestjs/platform-express": "^10.3.1",
-    "@nestjs/testing": "^10.3.1",
+    "@nestjs/platform-express": "^10.3.10",
+    "@nestjs/testing": "^10.3.10",
     "@types/lodash.head": "^4.0.9",
     "filedirname": "^3.4.0",
-    "ts-gems": "^3.1.1"
+    "rxjs": "^7.8.1",
+    "supertest": "^7.0.0",
+    "ts-gems": "^3.4.0"
   },
   "type": "module",
   "module": "./esm/index.js",
@@ -63,4 +66,4 @@
     "opra",
     "nestjs"
   ]
-}
+}

package/types/constants.d.ts

@@ -1,6 +1 @@
-export declare const OPRA_MODULE_OPTIONS = "opra:module_options";
-export declare const OPRA_MODULE_ID = "opra:module_id";
-export declare const OPRA_INITIALIZER = "opra_initializer";
-export declare const kOptions: unique symbol;
-export declare const kAdapter: unique symbol;
-export declare const PARAM_ARGS_METADATA = "__routeArguments__";
+export declare const IS_PUBLIC_KEY = "isPublic";

package/types/decorators/public.decorator.d.ts

@@ -0,0 +1 @@
+export declare const Public: () => import("@nestjs/common").CustomDecorator<string>;

package/types/index.d.ts

@@ -1,7 +1,6 @@
 import 'reflect-metadata';
-import './augmentation/common-decorator.augmentation.js';
 import './augmentation/nestjs.augmentation.js';
-export * from './opra.module.js';
-export * from './decorators/context.decorator.js';
-export * from './interfaces/opra-module-options.interface.js';
-export * from './opra-module-ref.js';
+export * from './constants.js';
+export * from './decorators/public.decorator.js';
+export * from './opra-http.module.js';
+export * from './opra-nestjs-adapter.js';

package/types/interfaces/opra-module-options.interface.d.ts

@@ -1,25 +0,0 @@
-import { ModuleMetadata, Type } from '@nestjs/common';
-import { ApiDocumentFactory } from '@opra/common';
-import { ExpressAdapter, NodeHttpAdapter } from '@opra/core';
-export type OpraModuleOptions = NodeHttpAdapter.Options & {
-    id?: any;
-    adapterNode?: ExpressAdapter.Options;
-    adapterExpress?: ExpressAdapter.Options;
-    document?: Partial<ApiDocumentFactory.InitArguments>;
-    /**
-     * @default true
-     */
-    useGlobalPrefix?: boolean;
-};
-type OpraModuleOptionsWithoutId = Omit<OpraModuleOptions, 'id'>;
-export interface OpraModuleOptionsFactory {
-    createOptions(): Promise<OpraModuleOptionsWithoutId> | OpraModuleOptionsWithoutId;
-}
-export interface OpraModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'providers'> {
-    id?: any;
-    useExisting?: Type<OpraModuleOptionsFactory>;
-    useClass?: Type<OpraModuleOptionsFactory>;
-    useFactory?: (...args: any[]) => Promise<OpraModuleOptionsWithoutId> | OpraModuleOptionsWithoutId;
-    inject?: any[];
-}
-export {};

package/types/opra-http-core.module.d.ts

@@ -0,0 +1,10 @@
+import { DynamicModule, MiddlewareConsumer, NestModule, OnModuleDestroy } from '@nestjs/common';
+import type { OpraHttpModule } from './opra-http.module';
+import { OpraNestAdapter } from './opra-nestjs-adapter.js';
+export declare class OpraHttpCoreModule implements OnModuleDestroy, NestModule {
+    protected opraAdapter: OpraNestAdapter;
+    constructor(opraAdapter: OpraNestAdapter);
+    configure(consumer: MiddlewareConsumer): void;
+    static forRoot(init: OpraHttpModule.Initiator, options?: OpraHttpModule.Options): DynamicModule;
+    onModuleDestroy(): Promise<void>;
+}

package/types/opra-http.module.d.ts

@@ -0,0 +1,20 @@
+import { DynamicModule } from '@nestjs/common';
+import { ApiDocumentFactory } from '@opra/common';
+export declare namespace OpraHttpModule {
+    interface Initiator extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers'>, Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'> {
+        id?: any;
+        name: string;
+    }
+    interface Options {
+        basePath?: string;
+        schemaRouteIsPublic?: boolean;
+    }
+}
+export declare class OpraHttpModule {
+    /**
+     *
+     * @param init
+     * @param options
+     */
+    static forRoot(init: OpraHttpModule.Initiator, options?: OpraHttpModule.Options): DynamicModule;
+}

package/types/opra-nestjs-adapter.d.ts

@@ -0,0 +1,12 @@
+import { Type } from '@nestjs/common';
+import { HttpAdapter } from '@opra/core';
+import type { OpraHttpModule } from './opra-http.module';
+export declare const kHandler: unique symbol;
+export declare class OpraNestAdapter extends HttpAdapter {
+    readonly nestControllers: Type[];
+    readonly options?: OpraHttpModule.Options;
+    constructor(init: OpraHttpModule.Initiator, options?: OpraHttpModule.Options);
+    close(): Promise<void>;
+    protected _addRootController(basePath: string): void;
+    protected _addToNestControllers(sourceClass: Type, currentPath: string): void;
+}

package/types/services/opra-exception-filter.d.ts

@@ -1,4 +1,8 @@
-import { ExceptionFilter } from '@nestjs/common';
+import { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
+import { OpraNestAdapter } from '../opra-nestjs-adapter.js';
+export declare const kHandler: unique symbol;
 export declare class OpraExceptionFilter implements ExceptionFilter {
-    catch(exception: any): boolean;
+    readonly adapter: OpraNestAdapter;
+    constructor(adapter: OpraNestAdapter);
+    catch(exception: any, host: ArgumentsHost): Promise<void>;
 }

package/types/services/opra-middleware.d.ts

@@ -0,0 +1,5 @@
+import { NestMiddleware } from '@nestjs/common';
+import type { NextFunction, Request, Response } from 'express';
+export declare class OpraMiddleware implements NestMiddleware {
+    use(req: Request, res: Response, next: NextFunction): void;
+}

package/cjs/augmentation/common-decorator.augmentation.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@nestjs/common");
-const common_2 = require("@opra/common");
-/*
-  Overrides Collection decorator function to call NestJS's Injectable() when Collection decorator called
- */
-const oldCollectionDecorator = common_2.Collection[common_2.DECORATOR];
-common_2.Collection[common_2.DECORATOR] = function CollectionDecorator(...args) {
-    const collectionDecorator = oldCollectionDecorator(...args);
-    const injectableDecorator = (0, common_1.Injectable)();
-    return (target) => {
-        collectionDecorator(target);
-        injectableDecorator(target);
-    };
-};
-/*
-  Overrides Singleton decorator function to call NestJS's Injectable() when Singleton decorator called
- */
-const oldSingletonDecorator = common_2.Singleton[common_2.DECORATOR];
-common_2.Singleton[common_2.DECORATOR] = function SingletonDecorator(...args) {
-    const singletonDecorator = oldSingletonDecorator(...args);
-    const injectableDecorator = (0, common_1.Injectable)();
-    return (target) => {
-        singletonDecorator(target);
-        injectableDecorator(target);
-    };
-};
-/*
-  Overrides Singleton decorator function to call NestJS's Injectable() when Singleton decorator called
- */
-const oldStorageDecorator = common_2.Storage[common_2.DECORATOR];
-common_2.Storage[common_2.DECORATOR] = function StorageDecorator(...args) {
-    const storageDecorator = oldStorageDecorator(...args);
-    const injectableDecorator = (0, common_1.Injectable)();
-    return (target) => {
-        storageDecorator(target);
-        injectableDecorator(target);
-    };
-};

package/cjs/decorators/context.decorator.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = void 0;
-const handler_paramtype_enum_js_1 = require("../enums/handler-paramtype.enum.js");
-const param_utils_js_1 = require("../utils/param.utils.js");
-/**
- * Handler method parameter decorator. Populates the decorated
- * parameter with the value of `RequestContext`.
- */
-exports.Context = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.CONTEXT);

package/cjs/enums/handler-paramtype.enum.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HandlerParamType = void 0;
-var HandlerParamType;
-(function (HandlerParamType) {
-    HandlerParamType[HandlerParamType["CONTEXT"] = 0] = "CONTEXT";
-    HandlerParamType[HandlerParamType["REQUEST"] = 1] = "REQUEST";
-    HandlerParamType[HandlerParamType["RESPONSE"] = 2] = "RESPONSE";
-})(HandlerParamType || (exports.HandlerParamType = HandlerParamType = {}));

package/cjs/factories/opra-api.factory.js

@@ -1,200 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraApiFactory = void 0;
-const tslib_1 = require("tslib");
-const lodash_head_1 = tslib_1.__importDefault(require("lodash.head"));
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-const external_context_creator_1 = require("@nestjs/core/helpers/external-context-creator");
-const injector_1 = require("@nestjs/core/injector/injector");
-const internal_core_module_1 = require("@nestjs/core/injector/internal-core-module");
-const request_constants_1 = require("@nestjs/core/router/request/request-constants");
-const common_2 = require("@opra/common");
-const constants_js_1 = require("../constants.js");
-const handler_paramtype_enum_js_1 = require("../enums/handler-paramtype.enum.js");
-const nest_explorer_js_1 = require("../services/nest-explorer.js");
-const function_utils_js_1 = require("../utils/function.utils.js");
-const params_factory_js_1 = require("./params.factory.js");
-const noOpFunction = () => void 0;
-let OpraApiFactory = class OpraApiFactory {
-    constructor() {
-        this.paramsFactory = new params_factory_js_1.OpraParamsFactory();
-        this.injector = new injector_1.Injector();
-    }
-    async generateService(rootModule, contextType, apiSchema) {
-        const info = { ...apiSchema?.info };
-        info.title = info.title || 'Untitled service';
-        info.version = info.version || '1';
-        const root = {
-            resources: []
-        };
-        const apiInit = {
-            version: common_2.OpraSchema.SpecVersion,
-            ...apiSchema,
-            info,
-            types: apiSchema?.types || [],
-            root
-        };
-        /*
-         * Walk through modules and add Resource instances to the api schema
-         */
-        this.explorerService.exploreResources(rootModule, (wrapper, modulePath) => {
-            const instance = wrapper.instance;
-            const ctor = instance.constructor;
-            const metadata = Reflect.getMetadata(common_2.RESOURCE_METADATA, ctor);
-            let node = root;
-            modulePath.forEach(m => {
-                const mt = Reflect.getMetadata(common_2.RESOURCE_METADATA, m._metatype);
-                if (mt) {
-                    let n = node.resources.find(x => x.controller === m.instance);
-                    if (!n) {
-                        n = {
-                            ...mt,
-                            kind: 'Container',
-                            resources: [...(mt.resources || [])],
-                            controller: m.instance
-                        };
-                        node.resources.push(n);
-                    }
-                    node = n;
-                }
-            });
-            // Do not add Modules decorated with @Container
-            if (wrapper.metatype !== wrapper.host?.metatype)
-                node.resources.push(instance);
-            /* Wrap operation and action functions */
-            const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            const methodNames = [...Object.keys(metadata.operations || []), ...Object.keys(metadata.actions || [])];
-            for (const methodName of methodNames) {
-                const endpointFunction = instance[methodName];
-                const nestHandlerName = methodName + '_nestjs';
-                // Skip patch if controller do not have function for endpoint or already patched before
-                if (typeof endpointFunction !== 'function')
-                    continue;
-                // NestJs requires calling handler function in different order than Opra.
-                // In NestJS, handler functions must be called with these parameters (req, res, next)
-                // In Opra, handler functions must be called with these parameters (context)
-                // To work handlers properly we create new handlers that will work as a proxy to wrap parameters
-                // Opra request (context) -> Nest (req, res, next, context: QueryRequestContext) -> Opra response (context)
-                const paramArgsMetadata = Reflect.getMetadata(constants_js_1.PARAM_ARGS_METADATA, instance.constructor, methodName);
-                const hasParamsArgs = !!paramArgsMetadata;
-                const patchedFn = instance[nestHandlerName] = function (...args) {
-                    if (hasParamsArgs)
-                        return endpointFunction.apply(this, args);
-                    return endpointFunction.call(this, args[3]);
-                };
-                if (paramArgsMetadata)
-                    Reflect.defineMetadata(constants_js_1.PARAM_ARGS_METADATA, paramArgsMetadata, instance.constructor, nestHandlerName);
-                // Copy all metadata from old Function to new one
-                Reflect.getMetadataKeys(endpointFunction).forEach(k => {
-                    const m = Reflect.getMetadata(k, endpointFunction);
-                    Reflect.defineMetadata(k, m, patchedFn);
-                });
-                this._createContextCallback(instance, wrapper, rootModule, methodName, isRequestScoped, contextType);
-            }
-        });
-        // Create api document
-        return common_2.ApiDocumentFactory.createDocument(apiInit);
-    }
-    _createHandler(callback) {
-        return function (ctx) {
-            switch (ctx.protocol) {
-                case 'http':
-                    const httpContext = ctx.switchToHttp();
-                    return callback(httpContext.incoming, httpContext.outgoing, noOpFunction, ctx);
-                default:
-                    throw new Error(`"${ctx.protocol}" context type is not implemented yet`);
-            }
-        };
-    }
-    _createContextCallback(instance, wrapper, moduleRef, methodName, isRequestScoped, contextType, options) {
-        const paramsFactory = this.paramsFactory;
-        const nestHandlerName = methodName + '_nestjs';
-        const callback = isRequestScoped
-            ? async (...args) => {
-                const opraContext = paramsFactory.exchangeKeyForValue(handler_paramtype_enum_js_1.HandlerParamType.CONTEXT, undefined, args);
-                const contextId = this.getContextId(opraContext);
-                this.registerContextProvider(opraContext, contextId);
-                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, moduleRef.providers, contextId);
-                const contextCallback = this.externalContextCreator.create(contextInstance, contextInstance[methodName], nestHandlerName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
-                contextInstance[methodName] = this._createHandler(contextCallback);
-                return contextCallback(...args);
-            }
-            : this.externalContextCreator.create(instance, instance[nestHandlerName], nestHandlerName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
-        instance[methodName] = this._createHandler(callback);
-        return callback;
-    }
-    // noinspection JSMethodCanBeStatic
-    getContextId(gqlContext) {
-        const numberOfArguments = (0, function_utils_js_1.getNumberOfArguments)(core_1.ContextIdFactory.getByRequest);
-        if (numberOfArguments === 2) {
-            // @ts-ignore
-            const contextId = core_1.ContextIdFactory.getByRequest(gqlContext, ['req']);
-            if (!gqlContext[request_constants_1.REQUEST_CONTEXT_ID]) {
-                Object.defineProperty(gqlContext, request_constants_1.REQUEST_CONTEXT_ID, {
-                    value: contextId,
-                    enumerable: false,
-                    configurable: false,
-                    writable: false,
-                });
-            }
-            return contextId;
-        }
-        else {
-            // TODO remove in the next version (backward-compatibility layer)
-            // Left for backward compatibility purposes
-            let contextId;
-            if (gqlContext && gqlContext[request_constants_1.REQUEST_CONTEXT_ID]) {
-                contextId = gqlContext[request_constants_1.REQUEST_CONTEXT_ID];
-            }
-            else if (gqlContext &&
-                gqlContext.req &&
-                gqlContext.req[request_constants_1.REQUEST_CONTEXT_ID]) {
-                contextId = gqlContext.req[request_constants_1.REQUEST_CONTEXT_ID];
-            }
-            else {
-                contextId = (0, core_1.createContextId)();
-                Object.defineProperty(gqlContext, request_constants_1.REQUEST_CONTEXT_ID, {
-                    value: contextId,
-                    enumerable: false,
-                    configurable: false,
-                    writable: false,
-                });
-            }
-            return contextId;
-        }
-    }
-    registerContextProvider(request, contextId) {
-        const coreModuleArray = [...this.modulesContainer.entries()]
-            .filter(
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        ([key, { metatype }]) => metatype && metatype.name === internal_core_module_1.InternalCoreModule.name)
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            .map(([key, value]) => value);
-        const coreModuleRef = (0, lodash_head_1.default)(coreModuleArray);
-        if (!coreModuleRef) {
-            return;
-        }
-        const wrapper = coreModuleRef.getProviderByKey(core_1.REQUEST);
-        wrapper.setInstanceByContextId(contextId, {
-            instance: request,
-            isResolved: true,
-        });
-    }
-};
-exports.OpraApiFactory = OpraApiFactory;
-tslib_1.__decorate([
-    (0, common_1.Inject)(),
-    tslib_1.__metadata("design:type", core_1.ModulesContainer)
-], OpraApiFactory.prototype, "modulesContainer", void 0);
-tslib_1.__decorate([
-    (0, common_1.Inject)(),
-    tslib_1.__metadata("design:type", external_context_creator_1.ExternalContextCreator)
-], OpraApiFactory.prototype, "externalContextCreator", void 0);
-tslib_1.__decorate([
-    (0, common_1.Inject)(),
-    tslib_1.__metadata("design:type", nest_explorer_js_1.NestExplorer)
-], OpraApiFactory.prototype, "explorerService", void 0);
-exports.OpraApiFactory = OpraApiFactory = tslib_1.__decorate([
-    (0, common_1.Injectable)()
-], OpraApiFactory);