@opra/nestjs 0.14.0 → 0.16.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/constants.js

@@ -1,4 +1,7 @@
-export const OPRA_MODULE_OPTIONS = 'opra:module_options';
-export const OPRA_MODULE_ID = 'opra:module_id';
-export const OPRA_INITIALIZER = 'opra_initializer';
-export const PARAM_ARGS_METADATA = '__routeArguments__';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARAM_ARGS_METADATA = exports.OPRA_INITIALIZER = exports.OPRA_MODULE_ID = exports.OPRA_MODULE_OPTIONS = void 0;
+exports.OPRA_MODULE_OPTIONS = 'opra:module_options';
+exports.OPRA_MODULE_ID = 'opra:module_id';
+exports.OPRA_INITIALIZER = 'opra_initializer';
+exports.PARAM_ARGS_METADATA = '__routeArguments__';

package/esm/decorators/context.decorator.js

@@ -1,22 +1,15 @@
-import { HandlerParamType } from '../enums/handler-paramtype.enum.js';
-import { createOpraParamDecorator } from '../utils/param.utils.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
 /**
  * Handler method parameter decorator. Populates the decorated
  * 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);
+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 `OpraService`.
  */
-export const Query = createOpraParamDecorator(HandlerParamType.QUERY);
+exports.ApiDoc = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.API);

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

@@ -1,8 +1,10 @@
-export var HandlerParamType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 || (HandlerParamType = {}));
+})(HandlerParamType = exports.HandlerParamType || (exports.HandlerParamType = {}));

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

@@ -1,39 +1,53 @@
-import { __decorate, __metadata } from "tslib";
-import head from 'lodash.head';
-import identity from 'lodash.identity';
-import { Inject, Injectable } from '@nestjs/common';
-import { ContextIdFactory, createContextId, ModulesContainer, REQUEST } from '@nestjs/core';
-import { ExternalContextCreator } from '@nestjs/core/helpers/external-context-creator';
-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 { 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';
+"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 lodash_identity_1 = tslib_1.__importDefault(require("lodash.identity"));
+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;
-const METHOD_PATCHED = 'ServiceFactory.method-patched';
 let OpraApiFactory = class OpraApiFactory {
     constructor() {
-        this.paramsFactory = new OpraParamsFactory();
-        this.injector = new Injector();
+        this.paramsFactory = new params_factory_js_1.OpraParamsFactory();
+        this.injector = new injector_1.Injector();
     }
     async generateService(rootModule, moduleOptions, contextType) {
         const info = { title: '', version: '', ...moduleOptions.info };
         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(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;
@@ -41,97 +55,77 @@ 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 ((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 OpraDocument.create(serviceArgs);
+        // Create api document
+        return common_2.DocumentFactory.createDocument(apiSchema);
     }
-    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = identity, 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(HandlerParamType.CONTEXT, undefined, 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, 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, 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) {
-        const numberOfArguments = getNumberOfArguments(ContextIdFactory.getByRequest);
+        const numberOfArguments = (0, function_utils_js_1.getNumberOfArguments)(core_1.ContextIdFactory.getByRequest);
         if (numberOfArguments === 2) {
             // @ts-ignore
-            const contextId = ContextIdFactory.getByRequest(gqlContext, ['req']);
-            if (!gqlContext[REQUEST_CONTEXT_ID]) {
-                Object.defineProperty(gqlContext, REQUEST_CONTEXT_ID, {
+            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,
@@ -144,17 +138,17 @@ let OpraApiFactory = class OpraApiFactory {
             // TODO remove in the next version (backward-compatibility layer)
             // Left for backward compatibility purposes
             let contextId;
-            if (gqlContext && gqlContext[REQUEST_CONTEXT_ID]) {
-                contextId = gqlContext[REQUEST_CONTEXT_ID];
+            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_CONTEXT_ID]) {
-                contextId = gqlContext.req[REQUEST_CONTEXT_ID];
+                gqlContext.req[request_constants_1.REQUEST_CONTEXT_ID]) {
+                contextId = gqlContext.req[request_constants_1.REQUEST_CONTEXT_ID];
             }
             else {
-                contextId = createContextId();
-                Object.defineProperty(gqlContext, REQUEST_CONTEXT_ID, {
+                contextId = (0, core_1.createContextId)();
+                Object.defineProperty(gqlContext, request_constants_1.REQUEST_CONTEXT_ID, {
                     value: contextId,
                     enumerable: false,
                     configurable: false,
@@ -168,33 +162,33 @@ let OpraApiFactory = class OpraApiFactory {
         const coreModuleArray = [...this.modulesContainer.entries()]
             .filter(
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        ([key, { metatype }]) => metatype && metatype.name === InternalCoreModule.name)
+        ([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 = head(coreModuleArray);
+        const coreModuleRef = (0, lodash_head_1.default)(coreModuleArray);
         if (!coreModuleRef) {
             return;
         }
-        const wrapper = coreModuleRef.getProviderByKey(REQUEST);
+        const wrapper = coreModuleRef.getProviderByKey(core_1.REQUEST);
         wrapper.setInstanceByContextId(contextId, {
             instance: request,
             isResolved: true,
         });
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", ModulesContainer)
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", core_1.ModulesContainer)
 ], OpraApiFactory.prototype, "modulesContainer", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", ExternalContextCreator)
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", external_context_creator_1.ExternalContextCreator)
 ], OpraApiFactory.prototype, "externalContextCreator", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", NestExplorer)
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", nest_explorer_js_1.NestExplorer)
 ], OpraApiFactory.prototype, "explorerService", void 0);
-OpraApiFactory = __decorate([
-    Injectable()
+OpraApiFactory = tslib_1.__decorate([
+    (0, common_1.Injectable)()
 ], OpraApiFactory);
-export { OpraApiFactory };
+exports.OpraApiFactory = OpraApiFactory;

package/esm/factories/params.factory.js

@@ -1,23 +1,25 @@
-import { HandlerParamType } from '../enums/handler-paramtype.enum.js';
-export class OpraParamsFactory {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraParamsFactory = void 0;
+const handler_paramtype_enum_js_1 = require("../enums/handler-paramtype.enum.js");
+class OpraParamsFactory {
     exchangeKeyForValue(type, data, args) {
         if (!args) {
             return null;
         }
         args = Array.isArray(args) ? args : [];
         switch (type) {
-            case HandlerParamType.CONTEXT:
+            case handler_paramtype_enum_js_1.HandlerParamType.CONTEXT:
                 return args[3];
-            case HandlerParamType.SERVICE:
-                return args[3].service;
-            case HandlerParamType.QUERY:
-                return args[3].query;
-            case HandlerParamType.RESPONSE:
+            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 HandlerParamType.USER_CONTEXT:
-                return args[3].executionContext.userContext;
             default:
                 return null;
         }
     }
 }
+exports.OpraParamsFactory = OpraParamsFactory;

package/esm/index.js

@@ -1,5 +1,8 @@
-import 'reflect-metadata';
-export * from './opra.module.js';
-export * from './decorators/context.decorator.js';
-export * from './interfaces/opra-module-options.interface.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+tslib_1.__exportStar(require("./opra.module.js"), exports);
+tslib_1.__exportStar(require("./decorators/context.decorator.js"), exports);
+tslib_1.__exportStar(require("./interfaces/opra-module-options.interface.js"), exports);
 // export * as Api from './decorators/api.ns.js';

package/esm/interfaces/opra-module-options.interface.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/opra-core.module.js

@@ -1,13 +1,16 @@
+"use strict";
 var OpraCoreModule_1;
-import { __decorate, __metadata, __param } from "tslib";
-import * as crypto from 'crypto';
-import { Inject, Module } from '@nestjs/common';
-import { HttpAdapterHost, ModulesContainer } from '@nestjs/core';
-import { MetadataScanner } from '@nestjs/core/metadata-scanner';
-import { OPRA_INITIALIZER, OPRA_MODULE_ID, OPRA_MODULE_OPTIONS } from './constants.js';
-import { OpraApiFactory } from './factories/opra-api.factory.js';
-import { NestExplorer } from './services/nest-explorer.js';
-import { OpraApiLoader } from './services/opra-api-loader.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraCoreModule = void 0;
+const tslib_1 = require("tslib");
+const crypto = tslib_1.__importStar(require("crypto"));
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const metadata_scanner_1 = require("@nestjs/core/metadata-scanner");
+const constants_js_1 = require("./constants.js");
+const opra_api_factory_js_1 = require("./factories/opra-api.factory.js");
+const nest_explorer_js_1 = require("./services/nest-explorer.js");
+const opra_api_loader_js_1 = require("./services/opra-api-loader.js");
 let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
     constructor(httpAdapterHost, modulesContainer, options, opraServiceLoader) {
         this.httpAdapterHost = httpAdapterHost;
@@ -22,12 +25,12 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
             providers: [
                 ...(options.providers || []),
                 {
-                    provide: OPRA_MODULE_OPTIONS,
+                    provide: constants_js_1.OPRA_MODULE_OPTIONS,
                     useValue: options,
                 },
                 {
-                    provide: OPRA_INITIALIZER,
-                    useClass: OpraApiLoader
+                    provide: constants_js_1.OPRA_INITIALIZER,
+                    useClass: opra_api_loader_js_1.OpraApiLoader
                 }
             ],
             exports: [...(options.exports || [])]
@@ -40,12 +43,12 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
             providers: [
                 ...(asyncOptions.providers || []),
                 {
-                    provide: OPRA_MODULE_ID,
+                    provide: constants_js_1.OPRA_MODULE_ID,
                     useValue: crypto.randomUUID()
                 },
                 {
-                    provide: OPRA_INITIALIZER,
-                    useClass: OpraApiLoader
+                    provide: constants_js_1.OPRA_INITIALIZER,
+                    useClass: opra_api_loader_js_1.OpraApiLoader
                 },
                 ...this.createAsyncProviders(asyncOptions)
             ]
@@ -67,7 +70,7 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
     static createAsyncOptionsProvider(asyncOptions) {
         if (asyncOptions.useFactory) {
             return {
-                provide: OPRA_MODULE_OPTIONS,
+                provide: constants_js_1.OPRA_MODULE_OPTIONS,
                 useFactory: asyncOptions.useFactory,
                 inject: asyncOptions.inject || []
             };
@@ -75,7 +78,7 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
         const useClass = asyncOptions.useClass || asyncOptions.useExisting;
         if (useClass) {
             return {
-                provide: OPRA_MODULE_OPTIONS,
+                provide: constants_js_1.OPRA_MODULE_OPTIONS,
                 useFactory: (optionsFactory) => optionsFactory.createOptions(),
                 inject: [useClass]
             };
@@ -104,17 +107,17 @@ let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
         await this.opraServiceLoader.stop();
     }
 };
-OpraCoreModule = OpraCoreModule_1 = __decorate([
-    Module({
+OpraCoreModule = OpraCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({
         providers: [
-            OpraApiFactory,
-            MetadataScanner,
-            NestExplorer
+            opra_api_factory_js_1.OpraApiFactory,
+            metadata_scanner_1.MetadataScanner,
+            nest_explorer_js_1.NestExplorer
         ]
     }),
-    __param(2, Inject(OPRA_MODULE_OPTIONS)),
-    __param(3, Inject(OPRA_INITIALIZER)),
-    __metadata("design:paramtypes", [HttpAdapterHost,
-        ModulesContainer, Object, OpraApiLoader])
+    tslib_1.__param(2, (0, common_1.Inject)(constants_js_1.OPRA_MODULE_OPTIONS)),
+    tslib_1.__param(3, (0, common_1.Inject)(constants_js_1.OPRA_INITIALIZER)),
+    tslib_1.__metadata("design:paramtypes", [core_1.HttpAdapterHost,
+        core_1.ModulesContainer, Object, opra_api_loader_js_1.OpraApiLoader])
 ], OpraCoreModule);
-export { OpraCoreModule };
+exports.OpraCoreModule = OpraCoreModule;

package/esm/opra.module.js

@@ -1,22 +1,25 @@
+"use strict";
 var OpraModule_1;
-import { __decorate } from "tslib";
-import { Module } from '@nestjs/common';
-import { OpraCoreModule } from './opra-core.module.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const opra_core_module_js_1 = require("./opra-core.module.js");
 let OpraModule = OpraModule_1 = class OpraModule {
     static forRoot(options) {
         return {
             module: OpraModule_1,
-            imports: [OpraCoreModule.forRoot(options)]
+            imports: [opra_core_module_js_1.OpraCoreModule.forRoot(options)]
         };
     }
     static forRootAsync(asyncOptions) {
         return {
             module: OpraModule_1,
-            imports: [OpraCoreModule.forRootAsync(asyncOptions)]
+            imports: [opra_core_module_js_1.OpraCoreModule.forRootAsync(asyncOptions)]
         };
     }
 };
-OpraModule = OpraModule_1 = __decorate([
-    Module({})
+OpraModule = OpraModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
 ], OpraModule);
-export { OpraModule };
+exports.OpraModule = OpraModule;

package/esm/services/nest-explorer.js

@@ -1,5 +1,8 @@
-import { RESOURCE_METADATA } from '@opra/common';
-export class NestExplorer {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestExplorer = void 0;
+const common_1 = require("@opra/common");
+class NestExplorer {
     exploreProviders(rootModule, predicate) {
         const modules = new Set();
         const wrappers = new Set();
@@ -25,7 +28,8 @@ export class NestExplorer {
             return !!(wrapper.instance
                 && typeof wrapper.instance === 'object'
                 && wrapper.instance.constructor
-                && Reflect.hasMetadata(RESOURCE_METADATA, wrapper.instance.constructor));
+                && common_1.OpraSchema.isResource(Reflect.getMetadata(common_1.METADATA_KEY, wrapper.instance.constructor)));
         });
     }
 }
+exports.NestExplorer = NestExplorer;

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

@@ -1,20 +1,23 @@
-import { __decorate, __metadata } from "tslib";
-import { Inject, Logger } from '@nestjs/common';
-import { ApplicationConfig, HttpAdapterHost } from '@nestjs/core';
-import { joinPath, normalizePath } from '@opra/common';
-import { OpraExpressAdapter } from '@opra/core';
-import { OPRA_MODULE_OPTIONS } from '../constants.js';
-import { OpraApiFactory } from '../factories/opra-api.factory.js';
-export class OpraApiLoader {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraApiLoader = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const common_2 = require("@opra/common");
+const core_2 = require("@opra/core");
+const constants_js_1 = require("../constants.js");
+const opra_api_factory_js_1 = require("../factories/opra-api.factory.js");
+class OpraApiLoader {
     constructor() {
-        this.logger = new Logger(OpraApiLoader.name, { timestamp: true });
+        this.logger = new common_1.Logger(OpraApiLoader.name, { timestamp: true });
     }
     async initialize(rootModule) {
         const httpAdapter = this.httpAdapterHost?.httpAdapter;
         const globalPrefix = this.applicationConfig.getGlobalPrefix();
         const platformName = httpAdapter.getType();
         const moduleOptions = this.opraModuleOptions;
-        const prefix = '/' + normalizePath(joinPath((moduleOptions.useGlobalPrefix !== false ? globalPrefix : ''), moduleOptions.prefix || ''), true);
+        const prefix = '/' + (0, common_2.normalizePath)((0, common_2.joinPath)((moduleOptions.useGlobalPrefix !== false ? globalPrefix : ''), moduleOptions.prefix || ''), true);
         const name = moduleOptions.info?.title || 'untitled service';
         const options = {
             ...moduleOptions,
@@ -49,26 +52,31 @@ 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 common_1.Logger(service.info.title);
+            logger.fatal = logger.error.bind(logger);
+        }
+        return core_2.OpraExpressAdapter.create(app, service, {
             logger,
             ...moduleOptions
         });
     }
 }
-__decorate([
-    Inject(),
-    __metadata("design:type", HttpAdapterHost)
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", core_1.HttpAdapterHost)
 ], OpraApiLoader.prototype, "httpAdapterHost", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", ApplicationConfig)
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", core_1.ApplicationConfig)
 ], OpraApiLoader.prototype, "applicationConfig", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", OpraApiFactory)
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", opra_api_factory_js_1.OpraApiFactory)
 ], OpraApiLoader.prototype, "opraFactory", void 0);
-__decorate([
-    Inject(OPRA_MODULE_OPTIONS),
-    __metadata("design:type", Object)
+tslib_1.__decorate([
+    (0, common_1.Inject)(constants_js_1.OPRA_MODULE_OPTIONS),
+    tslib_1.__metadata("design:type", Object)
 ], OpraApiLoader.prototype, "opraModuleOptions", void 0);
+exports.OpraApiLoader = OpraApiLoader;

package/esm/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/utils/class.utils.js

@@ -1,19 +1,25 @@
-import { isFunction, isString } from '@nestjs/common/utils/shared.utils';
-export function isConstructor(obj) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClassName = exports.getClassOrUndefined = exports.isConstructor = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+function isConstructor(obj) {
     return typeof obj === 'function' &&
         !!(obj.prototype && obj.prototype.constructor);
 }
-export function getClassOrUndefined(typeOrFunc) {
+exports.isConstructor = isConstructor;
+function getClassOrUndefined(typeOrFunc) {
     return isConstructor(typeOrFunc)
         ? typeOrFunc
-        : isFunction(typeOrFunc)
+        : (0, shared_utils_1.isFunction)(typeOrFunc)
             ? typeOrFunc()
             : undefined;
 }
-export function getClassName(nameOrType) {
-    if (isString(nameOrType)) {
+exports.getClassOrUndefined = getClassOrUndefined;
+function getClassName(nameOrType) {
+    if ((0, shared_utils_1.isString)(nameOrType)) {
         return nameOrType;
     }
     const classOrUndefined = getClassOrUndefined(nameOrType);
     return classOrUndefined && classOrUndefined.name;
 }
+exports.getClassName = getClassName;

package/esm/utils/function.utils.js

@@ -1,7 +1,10 @@
-import { splitString, tokenize } from 'fast-tokenizer';
-export function getNumberOfArguments(fn) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNumberOfArguments = void 0;
+const fast_tokenizer_1 = require("fast-tokenizer");
+function getNumberOfArguments(fn) {
     const functionAsString = fn.toString();
-    const tokenizer = tokenize(functionAsString, {
+    const tokenizer = (0, fast_tokenizer_1.tokenize)(functionAsString, {
         // keepBrackets: true,
         keepDelimiters: true,
         keepQuotes: true,
@@ -21,7 +24,7 @@ export function getNumberOfArguments(fn) {
         else if (k)
             s += token;
     }
-    const x = splitString(s, {
+    const x = (0, fast_tokenizer_1.splitString)(s, {
         brackets: {
             '{': '}',
             '(': ')',
@@ -31,3 +34,4 @@ export function getNumberOfArguments(fn) {
     });
     return x.length > 1 ? x.length : (x[0] ? 1 : 0);
 }
+exports.getNumberOfArguments = getNumberOfArguments;

package/esm/utils/param.utils.js

@@ -1,5 +1,8 @@
-import 'reflect-metadata';
-import { PARAM_ARGS_METADATA } from '../constants.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpraParamDecorator = void 0;
+require("reflect-metadata");
+const constants_js_1 = require("../constants.js");
 function assignMetadata(args, paramType, index, data, ...pipes) {
     return {
         ...args,
@@ -10,9 +13,12 @@ function assignMetadata(args, paramType, index, data, ...pipes) {
         },
     };
 }
-export function createOpraParamDecorator(paramType) {
+function createOpraParamDecorator(paramType) {
     return (target, key, index) => {
-        const args = Reflect.getMetadata(PARAM_ARGS_METADATA, target.constructor, key) || {};
-        Reflect.defineMetadata(PARAM_ARGS_METADATA, assignMetadata(args, paramType, index), target.constructor, key);
+        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);
     };
 }
+exports.createOpraParamDecorator = createOpraParamDecorator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/nestjs",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
@@ -17,32 +17,32 @@
     "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.14.0",
-    "@opra/core": "^0.14.0",
-    "fast-tokenizer": "^1.2.1",
+    "@opra/common": "^0.16.0",
+    "@opra/core": "^0.16.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.194",
     "filedirname": "^2.7.0"
   },
   "type": "module",
-  "types": "esm/index.d.ts",
+  "types": "types/index.d.ts",
   "exports": {
     ".": {
       "require": "./cjs/index.js",
@@ -59,6 +59,7 @@
     "bin/",
     "cjs/",
     "esm/",
+    "types/",
     "LICENSE",
     "README.md"
   ],

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

@@ -0,0 +1,10 @@
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `RequestContext`.
+ */
+export declare const Context: ParameterDecorator;
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `OpraService`.
+ */
+export declare const ApiDoc: ParameterDecorator;

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

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

package/{esm → types}/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 → types}/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/decorators/context.decorator.d.ts

@@ -1,20 +0,0 @@
-/**
- * Handler method parameter decorator. Populates the decorated
- * 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;

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

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