@opra/nestjs 0.13.0 → 0.15.0

package/cjs/decorators/context.decorator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Query = exports.Service = exports.Response = exports.Context = void 0;
+exports.ApiDoc = 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");
 /**
@@ -8,18 +8,8 @@ const param_utils_js_1 = require("../utils/param.utils.js");
  * parameter with the value of `RequestContext`.
  */
 exports.Context = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.CONTEXT);
-/**
- * Handler method parameter decorator. Populates the decorated
- * parameter with the value of `QueryResponse`.
- */
-exports.Response = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.RESPONSE);
-/**
- * Handler method parameter decorator. Populates the decorated
- * parameter with the value of `OpraService`.
- */
-exports.Service = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.SERVICE);
 /**
  * Handler method parameter decorator. Populates the decorated
  * parameter with the value of `OpraService`.
  */
-exports.Query = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.QUERY);
+exports.ApiDoc = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.API);

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

@@ -4,8 +4,7 @@ exports.HandlerParamType = void 0;
 var HandlerParamType;
 (function (HandlerParamType) {
     HandlerParamType[HandlerParamType["CONTEXT"] = 0] = "CONTEXT";
-    HandlerParamType[HandlerParamType["SERVICE"] = 1] = "SERVICE";
-    HandlerParamType[HandlerParamType["QUERY"] = 2] = "QUERY";
+    HandlerParamType[HandlerParamType["API"] = 1] = "API";
+    HandlerParamType[HandlerParamType["REQUEST"] = 2] = "REQUEST";
     HandlerParamType[HandlerParamType["RESPONSE"] = 3] = "RESPONSE";
-    HandlerParamType[HandlerParamType["USER_CONTEXT"] = 4] = "USER_CONTEXT";
 })(HandlerParamType = exports.HandlerParamType || (exports.HandlerParamType = {}));

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

@@ -17,7 +17,6 @@ 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;
-const METHOD_PATCHED = 'ServiceFactory.method-patched';
 let OpraApiFactory = class OpraApiFactory {
     constructor() {
         this.paramsFactory = new params_factory_js_1.OpraParamsFactory();
@@ -28,15 +27,27 @@ let OpraApiFactory = class OpraApiFactory {
         info.title = info.title || 'Untitled service';
         info.version = info.version || '1';
         const resources = [];
-        const serviceArgs = {
+        const apiSchema = {
+            version: common_2.OpraSchema.SpecVersion,
             info,
             types: [],
             resources,
         };
+        /*
+         * Walk through modules and add Resource instances to the api schema
+         */
         const wrappers = this.explorerService.exploreResourceWrappers(rootModule);
         for (const wrapper of wrappers) {
             const instance = wrapper.instance;
-            const resourceDef = Reflect.getMetadata(common_2.RESOURCE_METADATA, instance.constructor);
+            const ctor = instance.constructor;
+            const metadata = Reflect.getMetadata(common_2.METADATA_KEY, ctor);
+            if (common_2.OpraSchema.isResource(metadata))
+                resources.push(instance);
+        }
+        for (const wrapper of wrappers) {
+            const instance = wrapper.instance;
+            const ctor = instance.constructor;
+            const resourceDef = Reflect.getMetadata(common_2.METADATA_KEY, ctor);
             /* istanbul ignore next */
             if (!resourceDef)
                 continue;
@@ -44,88 +55,68 @@ let OpraApiFactory = class OpraApiFactory {
             /* Wrap resolver functions */
             const prototype = Object.getPrototypeOf(instance);
             const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            const methodsToWrap = common_2.OpraSchema.isCollectionResource(resourceDef) ? common_2.collectionMethods : [];
-            for (const methodName of methodsToWrap) {
-                const fn = prototype[methodName];
-                if (typeof fn !== 'function')
-                    continue;
-                // We add special non-operational "prepare" method to prototype.
-                // This allows us to call Guards, Interceptors etc, before calling handler method
-                const oldPreFn = prototype['pre_' + methodName] = noOpFunction;
-                // Copy all metadata info
-                Reflect.getMetadataKeys(fn).forEach(k => {
-                    const metadata = Reflect.getMetadata(k, fn);
-                    Reflect.defineMetadata(k, metadata, oldPreFn);
-                });
-                const preCallback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType, true);
-                const newPreFn = instance['pre_' + methodName] = function (ctx) {
-                    switch (ctx.type) {
-                        case 'http':
-                            const http = ctx.switchToHttp();
-                            const req = http.getRequest().getInstance();
-                            const res = http.getResponse().getInstance();
-                            return preCallback(req, res, noOpFunction, ctx);
-                        default:
-                            throw new Error(`"${ctx.type}" context type is not implemented yet`);
-                    }
-                };
-                Object.defineProperty(newPreFn, 'name', {
-                    configurable: false,
-                    writable: false,
-                    enumerable: true,
-                    value: 'pre_' + methodName
-                });
-                if (!Reflect.hasMetadata(METHOD_PATCHED, fn)) {
-                    const hasParamsArgs = Reflect.hasMetadata(constants_js_1.PARAM_ARGS_METADATA, instance.constructor, methodName);
-                    const patchedFn = prototype[methodName] = function (...args) {
+            // const methodsToWrap = OpraSchema.isCollectionResource(resourceDef) ? collectionMethods : [];
+            if ((common_2.OpraSchema.isCollection(resourceDef) || common_2.OpraSchema.isSingleton(resourceDef)) && resourceDef.operations) {
+                for (const opr of Object.values(resourceDef.operations)) {
+                    const { handlerName } = opr;
+                    const fn = prototype[handlerName];
+                    if (typeof fn !== '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 nestHandlerName = handlerName + '::nestjs';
+                    const paramArgsMetadata = Reflect.getMetadata(constants_js_1.PARAM_ARGS_METADATA, instance.constructor, handlerName);
+                    const hasParamsArgs = !!paramArgsMetadata;
+                    const patchedFn = prototype[nestHandlerName] = function (...args) {
                         if (hasParamsArgs)
                             return fn.apply(this, args);
                         return fn.call(this, args[3]);
                     };
-                    Reflect.defineMetadata(METHOD_PATCHED, true, patchedFn);
+                    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(fn).forEach(k => {
-                        const metadata = Reflect.getMetadata(k, fn);
-                        Reflect.defineMetadata(k, metadata, patchedFn);
+                        const m = Reflect.getMetadata(k, fn);
+                        Reflect.defineMetadata(k, m, patchedFn);
+                    });
+                    const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, nestHandlerName, isRequestScoped, undefined, contextType);
+                    opr.handler = function (ctx) {
+                        switch (ctx.protocol) {
+                            case 'http':
+                                const httpContext = ctx.switchToHttp();
+                                return callback(httpContext.request, httpContext.response, noOpFunction, ctx);
+                            default:
+                                throw new Error(`"${ctx.protocol}" context type is not implemented yet`);
+                        }
+                    };
+                    Object.defineProperty(opr.handler, 'name', {
+                        configurable: false,
+                        writable: false,
+                        enumerable: true,
+                        value: handlerName
                     });
                 }
-                const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType, false);
-                const newFn = instance[methodName] = function (ctx) {
-                    switch (ctx.type) {
-                        case 'http':
-                            const http = ctx.switchToHttp();
-                            const req = http.getRequest().getInstance();
-                            const res = http.getResponse().getInstance();
-                            return callback(req, res, noOpFunction, ctx);
-                        default:
-                            throw new Error(`"${ctx.type}" context type is not implemented yet`);
-                    }
-                };
-                Object.defineProperty(newFn, 'name', {
-                    configurable: false,
-                    writable: false,
-                    enumerable: true,
-                    value: methodName
-                });
             }
         }
-        return await common_2.OpraDocument.create(serviceArgs);
+        // Create api document
+        return common_2.DocumentFactory.createDocument(apiSchema);
     }
-    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = lodash_identity_1.default, contextType, forPre) {
+    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = lodash_identity_1.default, contextType, options) {
         const paramsFactory = this.paramsFactory;
-        const options = !forPre ?
-            { guards: false, interceptors: false, filters: false } : undefined;
-        const fnName = forPre ? 'pre_' + methodName : methodName;
         if (isRequestScoped) {
             return 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 callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[fnName]), methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.type);
+                const callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[methodName]), methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
                 return callback(...args);
             };
         }
-        return this.externalContextCreator.create(instance, prototype[fnName], methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
+        return this.externalContextCreator.create(instance, prototype[methodName], methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
     }
     // noinspection JSMethodCanBeStatic
     getContextId(gqlContext) {

package/cjs/factories/params.factory.js

@@ -11,14 +11,12 @@ class OpraParamsFactory {
         switch (type) {
             case handler_paramtype_enum_js_1.HandlerParamType.CONTEXT:
                 return args[3];
-            case handler_paramtype_enum_js_1.HandlerParamType.SERVICE:
-                return args[3].service;
-            case handler_paramtype_enum_js_1.HandlerParamType.QUERY:
-                return args[3].query;
+            case handler_paramtype_enum_js_1.HandlerParamType.API:
+                return args[3].api;
+            case handler_paramtype_enum_js_1.HandlerParamType.REQUEST:
+                return args[3].request;
             case handler_paramtype_enum_js_1.HandlerParamType.RESPONSE:
                 return args[3].response;
-            case handler_paramtype_enum_js_1.HandlerParamType.USER_CONTEXT:
-                return args[3].executionContext.userContext;
             default:
                 return null;
         }

package/cjs/services/nest-explorer.js

@@ -28,7 +28,7 @@ class NestExplorer {
             return !!(wrapper.instance
                 && typeof wrapper.instance === 'object'
                 && wrapper.instance.constructor
-                && Reflect.hasMetadata(common_1.RESOURCE_METADATA, wrapper.instance.constructor));
+                && common_1.OpraSchema.isResource(Reflect.getMetadata(common_1.METADATA_KEY, wrapper.instance.constructor)));
         });
     }
 }

package/cjs/services/opra-api-loader.js

@@ -52,8 +52,12 @@ class OpraApiLoader {
         if (!httpAdapter)
             return;
         const app = httpAdapter.getInstance();
-        const logger = moduleOptions.logger || new common_1.Logger(service.info.title);
-        return core_2.OpraExpressAdapter.init(app, service, {
+        let logger = moduleOptions.logger;
+        if (!logger) {
+            logger = new common_1.Logger(service.info.title);
+            logger.fatal = logger.error.bind(logger);
+        }
+        return core_2.OpraExpressAdapter.create(app, service, {
             logger,
             ...moduleOptions
         });

package/cjs/utils/param.utils.js

@@ -15,6 +15,8 @@ function assignMetadata(args, paramType, index, data, ...pipes) {
 }
 function createOpraParamDecorator(paramType) {
     return (target, key, index) => {
+        if (!key)
+            return;
         const args = Reflect.getMetadata(constants_js_1.PARAM_ARGS_METADATA, target.constructor, key) || {};
         Reflect.defineMetadata(constants_js_1.PARAM_ARGS_METADATA, assignMetadata(args, paramType, index), target.constructor, key);
     };

package/esm/decorators/context.decorator.d.ts

@@ -3,18 +3,8 @@
  * parameter with the value of `RequestContext`.
  */
 export declare const Context: ParameterDecorator;
-/**
- * Handler method parameter decorator. Populates the decorated
- * parameter with the value of `QueryResponse`.
- */
-export declare const Response: ParameterDecorator;
-/**
- * Handler method parameter decorator. Populates the decorated
- * parameter with the value of `OpraService`.
- */
-export declare const Service: ParameterDecorator;
 /**
  * Handler method parameter decorator. Populates the decorated
  * parameter with the value of `OpraService`.
  */
-export declare const Query: ParameterDecorator;
+export declare const ApiDoc: ParameterDecorator;

package/esm/decorators/context.decorator.js

@@ -5,18 +5,8 @@ import { createOpraParamDecorator } from '../utils/param.utils.js';
  * parameter with the value of `RequestContext`.
  */
 export const Context = createOpraParamDecorator(HandlerParamType.CONTEXT);
-/**
- * Handler method parameter decorator. Populates the decorated
- * parameter with the value of `QueryResponse`.
- */
-export const Response = createOpraParamDecorator(HandlerParamType.RESPONSE);
-/**
- * Handler method parameter decorator. Populates the decorated
- * parameter with the value of `OpraService`.
- */
-export const Service = createOpraParamDecorator(HandlerParamType.SERVICE);
 /**
  * Handler method parameter decorator. Populates the decorated
  * parameter with the value of `OpraService`.
  */
-export const Query = createOpraParamDecorator(HandlerParamType.QUERY);
+export const ApiDoc = createOpraParamDecorator(HandlerParamType.API);

package/esm/enums/handler-paramtype.enum.d.ts

@@ -1,7 +1,6 @@
 export declare enum HandlerParamType {
     CONTEXT = 0,
-    SERVICE = 1,
-    QUERY = 2,
-    RESPONSE = 3,
-    USER_CONTEXT = 4
+    API = 1,
+    REQUEST = 2,
+    RESPONSE = 3
 }

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

@@ -1,8 +1,7 @@
 export var HandlerParamType;
 (function (HandlerParamType) {
     HandlerParamType[HandlerParamType["CONTEXT"] = 0] = "CONTEXT";
-    HandlerParamType[HandlerParamType["SERVICE"] = 1] = "SERVICE";
-    HandlerParamType[HandlerParamType["QUERY"] = 2] = "QUERY";
+    HandlerParamType[HandlerParamType["API"] = 1] = "API";
+    HandlerParamType[HandlerParamType["REQUEST"] = 2] = "REQUEST";
     HandlerParamType[HandlerParamType["RESPONSE"] = 3] = "RESPONSE";
-    HandlerParamType[HandlerParamType["USER_CONTEXT"] = 4] = "USER_CONTEXT";
 })(HandlerParamType || (HandlerParamType = {}));

package/esm/factories/opra-api.factory.d.ts

@@ -1,6 +1,6 @@
 import { ContextType } from '@nestjs/common';
 import { Module } from '@nestjs/core/injector/module.js';
-import { OpraDocument } from '@opra/common';
+import { ApiDocument } from '@opra/common';
 import { OpraModuleOptions } from '../interfaces/opra-module-options.interface.js';
 export declare class OpraApiFactory {
     private readonly paramsFactory;
@@ -8,7 +8,7 @@ export declare class OpraApiFactory {
     private readonly modulesContainer;
     private readonly externalContextCreator;
     private readonly explorerService;
-    generateService(rootModule: Module, moduleOptions: OpraModuleOptions, contextType: ContextType): Promise<OpraDocument>;
+    generateService(rootModule: Module, moduleOptions: OpraModuleOptions, contextType: ContextType): Promise<ApiDocument>;
     private _createContextCallback;
     private getContextId;
     private registerContextProvider;

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

@@ -7,14 +7,13 @@ import { ExternalContextCreator } from '@nestjs/core/helpers/external-context-cr
 import { Injector } from '@nestjs/core/injector/injector';
 import { InternalCoreModule } from '@nestjs/core/injector/internal-core-module';
 import { REQUEST_CONTEXT_ID } from '@nestjs/core/router/request/request-constants';
-import { collectionMethods, OpraDocument, OpraSchema, RESOURCE_METADATA } from '@opra/common';
+import { DocumentFactory, METADATA_KEY, OpraSchema } from '@opra/common';
 import { PARAM_ARGS_METADATA } from '../constants.js';
 import { HandlerParamType } from '../enums/handler-paramtype.enum.js';
 import { NestExplorer } from '../services/nest-explorer.js';
 import { getNumberOfArguments } from '../utils/function.utils.js';
 import { OpraParamsFactory } from './params.factory.js';
 const noOpFunction = () => void 0;
-const METHOD_PATCHED = 'ServiceFactory.method-patched';
 let OpraApiFactory = class OpraApiFactory {
     constructor() {
         this.paramsFactory = new OpraParamsFactory();
@@ -25,15 +24,27 @@ let OpraApiFactory = class OpraApiFactory {
         info.title = info.title || 'Untitled service';
         info.version = info.version || '1';
         const resources = [];
-        const serviceArgs = {
+        const apiSchema = {
+            version: OpraSchema.SpecVersion,
             info,
             types: [],
             resources,
         };
+        /*
+         * Walk through modules and add Resource instances to the api schema
+         */
         const wrappers = this.explorerService.exploreResourceWrappers(rootModule);
         for (const wrapper of wrappers) {
             const instance = wrapper.instance;
-            const resourceDef = Reflect.getMetadata(RESOURCE_METADATA, instance.constructor);
+            const ctor = instance.constructor;
+            const metadata = Reflect.getMetadata(METADATA_KEY, ctor);
+            if (OpraSchema.isResource(metadata))
+                resources.push(instance);
+        }
+        for (const wrapper of wrappers) {
+            const instance = wrapper.instance;
+            const ctor = instance.constructor;
+            const resourceDef = Reflect.getMetadata(METADATA_KEY, ctor);
             /* istanbul ignore next */
             if (!resourceDef)
                 continue;
@@ -41,88 +52,68 @@ let OpraApiFactory = class OpraApiFactory {
             /* Wrap resolver functions */
             const prototype = Object.getPrototypeOf(instance);
             const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            const methodsToWrap = OpraSchema.isCollectionResource(resourceDef) ? collectionMethods : [];
-            for (const methodName of methodsToWrap) {
-                const fn = prototype[methodName];
-                if (typeof fn !== 'function')
-                    continue;
-                // We add special non-operational "prepare" method to prototype.
-                // This allows us to call Guards, Interceptors etc, before calling handler method
-                const oldPreFn = prototype['pre_' + methodName] = noOpFunction;
-                // Copy all metadata info
-                Reflect.getMetadataKeys(fn).forEach(k => {
-                    const metadata = Reflect.getMetadata(k, fn);
-                    Reflect.defineMetadata(k, metadata, oldPreFn);
-                });
-                const preCallback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType, true);
-                const newPreFn = instance['pre_' + methodName] = function (ctx) {
-                    switch (ctx.type) {
-                        case 'http':
-                            const http = ctx.switchToHttp();
-                            const req = http.getRequest().getInstance();
-                            const res = http.getResponse().getInstance();
-                            return preCallback(req, res, noOpFunction, ctx);
-                        default:
-                            throw new Error(`"${ctx.type}" context type is not implemented yet`);
-                    }
-                };
-                Object.defineProperty(newPreFn, 'name', {
-                    configurable: false,
-                    writable: false,
-                    enumerable: true,
-                    value: 'pre_' + methodName
-                });
-                if (!Reflect.hasMetadata(METHOD_PATCHED, fn)) {
-                    const hasParamsArgs = Reflect.hasMetadata(PARAM_ARGS_METADATA, instance.constructor, methodName);
-                    const patchedFn = prototype[methodName] = function (...args) {
+            // const methodsToWrap = OpraSchema.isCollectionResource(resourceDef) ? collectionMethods : [];
+            if ((OpraSchema.isCollection(resourceDef) || OpraSchema.isSingleton(resourceDef)) && resourceDef.operations) {
+                for (const opr of Object.values(resourceDef.operations)) {
+                    const { handlerName } = opr;
+                    const fn = prototype[handlerName];
+                    if (typeof fn !== '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 nestHandlerName = handlerName + '::nestjs';
+                    const paramArgsMetadata = Reflect.getMetadata(PARAM_ARGS_METADATA, instance.constructor, handlerName);
+                    const hasParamsArgs = !!paramArgsMetadata;
+                    const patchedFn = prototype[nestHandlerName] = function (...args) {
                         if (hasParamsArgs)
                             return fn.apply(this, args);
                         return fn.call(this, args[3]);
                     };
-                    Reflect.defineMetadata(METHOD_PATCHED, true, patchedFn);
+                    if (paramArgsMetadata)
+                        Reflect.defineMetadata(PARAM_ARGS_METADATA, paramArgsMetadata, instance.constructor, nestHandlerName);
+                    // Copy all metadata from old Function to new one
                     Reflect.getMetadataKeys(fn).forEach(k => {
-                        const metadata = Reflect.getMetadata(k, fn);
-                        Reflect.defineMetadata(k, metadata, patchedFn);
+                        const m = Reflect.getMetadata(k, fn);
+                        Reflect.defineMetadata(k, m, patchedFn);
+                    });
+                    const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, nestHandlerName, isRequestScoped, undefined, contextType);
+                    opr.handler = function (ctx) {
+                        switch (ctx.protocol) {
+                            case 'http':
+                                const httpContext = ctx.switchToHttp();
+                                return callback(httpContext.request, httpContext.response, noOpFunction, ctx);
+                            default:
+                                throw new Error(`"${ctx.protocol}" context type is not implemented yet`);
+                        }
+                    };
+                    Object.defineProperty(opr.handler, 'name', {
+                        configurable: false,
+                        writable: false,
+                        enumerable: true,
+                        value: handlerName
                     });
                 }
-                const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType, false);
-                const newFn = instance[methodName] = function (ctx) {
-                    switch (ctx.type) {
-                        case 'http':
-                            const http = ctx.switchToHttp();
-                            const req = http.getRequest().getInstance();
-                            const res = http.getResponse().getInstance();
-                            return callback(req, res, noOpFunction, ctx);
-                        default:
-                            throw new Error(`"${ctx.type}" context type is not implemented yet`);
-                    }
-                };
-                Object.defineProperty(newFn, 'name', {
-                    configurable: false,
-                    writable: false,
-                    enumerable: true,
-                    value: methodName
-                });
             }
         }
-        return await OpraDocument.create(serviceArgs);
+        // Create api document
+        return DocumentFactory.createDocument(apiSchema);
     }
-    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = identity, contextType, forPre) {
+    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = identity, contextType, options) {
         const paramsFactory = this.paramsFactory;
-        const options = !forPre ?
-            { guards: false, interceptors: false, filters: false } : undefined;
-        const fnName = forPre ? 'pre_' + methodName : methodName;
         if (isRequestScoped) {
             return async (...args) => {
                 const opraContext = paramsFactory.exchangeKeyForValue(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 callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[fnName]), methodName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.type);
+                const callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[methodName]), methodName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
                 return callback(...args);
             };
         }
-        return this.externalContextCreator.create(instance, prototype[fnName], methodName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
+        return this.externalContextCreator.create(instance, prototype[methodName], methodName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
     }
     // noinspection JSMethodCanBeStatic
     getContextId(gqlContext) {

package/esm/factories/params.factory.js

@@ -8,14 +8,12 @@ export class OpraParamsFactory {
         switch (type) {
             case HandlerParamType.CONTEXT:
                 return args[3];
-            case HandlerParamType.SERVICE:
-                return args[3].service;
-            case HandlerParamType.QUERY:
-                return args[3].query;
+            case HandlerParamType.API:
+                return args[3].api;
+            case HandlerParamType.REQUEST:
+                return args[3].request;
             case HandlerParamType.RESPONSE:
                 return args[3].response;
-            case HandlerParamType.USER_CONTEXT:
-                return args[3].executionContext.userContext;
             default:
                 return null;
         }

package/esm/services/nest-explorer.js

@@ -1,4 +1,4 @@
-import { RESOURCE_METADATA } from '@opra/common';
+import { METADATA_KEY, OpraSchema } from '@opra/common';
 export class NestExplorer {
     exploreProviders(rootModule, predicate) {
         const modules = new Set();
@@ -25,7 +25,7 @@ export class NestExplorer {
             return !!(wrapper.instance
                 && typeof wrapper.instance === 'object'
                 && wrapper.instance.constructor
-                && Reflect.hasMetadata(RESOURCE_METADATA, wrapper.instance.constructor));
+                && OpraSchema.isResource(Reflect.getMetadata(METADATA_KEY, wrapper.instance.constructor)));
         });
     }
 }

package/esm/services/opra-api-loader.d.ts

@@ -1,6 +1,6 @@
 import { ApplicationConfig, HttpAdapterHost } from '@nestjs/core';
 import { Module } from '@nestjs/core/injector/module.js';
-import { OpraDocument } from '@opra/common';
+import { ApiDocument } from '@opra/common';
 import { OpraExpressAdapter } from '@opra/core';
 import { OpraApiFactory } from '../factories/opra-api.factory.js';
 import { OpraModuleOptions } from '../interfaces/opra-module-options.interface.js';
@@ -13,5 +13,5 @@ export declare class OpraApiLoader {
     protected readonly opraModuleOptions: OpraModuleOptions;
     initialize(rootModule: Module): Promise<void>;
     stop(): Promise<void>;
-    protected registerExpress(service: OpraDocument, moduleOptions: OpraModuleOptions): Promise<OpraExpressAdapter | undefined>;
+    protected registerExpress(service: ApiDocument, moduleOptions: OpraModuleOptions): Promise<OpraExpressAdapter | undefined>;
 }

package/esm/services/opra-api-loader.js

@@ -49,8 +49,12 @@ export class OpraApiLoader {
         if (!httpAdapter)
             return;
         const app = httpAdapter.getInstance();
-        const logger = moduleOptions.logger || new Logger(service.info.title);
-        return OpraExpressAdapter.init(app, service, {
+        let logger = moduleOptions.logger;
+        if (!logger) {
+            logger = new Logger(service.info.title);
+            logger.fatal = logger.error.bind(logger);
+        }
+        return OpraExpressAdapter.create(app, service, {
             logger,
             ...moduleOptions
         });

package/esm/utils/param.utils.js

@@ -12,6 +12,8 @@ function assignMetadata(args, paramType, index, data, ...pipes) {
 }
 export function createOpraParamDecorator(paramType) {
     return (target, key, index) => {
+        if (!key)
+            return;
         const args = Reflect.getMetadata(PARAM_ARGS_METADATA, target.constructor, key) || {};
         Reflect.defineMetadata(PARAM_ARGS_METADATA, assignMetadata(args, paramType, index), target.constructor, key);
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/nestjs",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
@@ -17,28 +17,28 @@
     "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 .",
-    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest",
-    "cover": "NODE_OPTIONS=--experimental-vm-modules npx jest --collect-coverage",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all && ts-cleanup -s test --all",
     "clean:dist": "rimraf ../../build/nestjs",
     "clean:cover": "rimraf ../../coverage/nestjs"
   },
   "dependencies": {
-    "@opra/common": "^0.13.0",
-    "@opra/core": "^0.13.0",
-    "fast-tokenizer": "^1.2.1",
+    "@opra/common": "^0.15.0",
+    "@opra/core": "^0.15.0",
+    "fast-tokenizer": "^1.2.2",
     "lodash.head": "^4.0.1",
     "lodash.identity": "^3.0.0",
     "reflect-metadata": "^0.1.13"
   },
   "peerDependencies": {
-    "@nestjs/common": "^9.2.1"
+    "@nestjs/common": "^9.4.0"
   },
   "devDependencies": {
-    "@nestjs/platform-express": "^9.2.1",
-    "@nestjs/testing": "^9.2.1",
-    "@types/lodash": "^4.14.191",
+    "@nestjs/platform-express": "^9.4.0",
+    "@nestjs/testing": "^9.4.0",
+    "@types/lodash": "^4.14.192",
     "filedirname": "^2.7.0"
   },
   "type": "module",