@opra/nestjs 0.22.0 → 0.23.0

package/cjs/decorators/context.decorator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiDoc = exports.Context = void 0;
+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,8 +8,3 @@ 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 `OpraService`.
- */
-exports.ApiDoc = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.API);

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

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

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

@@ -3,7 +3,6 @@ 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");
@@ -53,70 +52,68 @@ let OpraApiFactory = exports.OpraApiFactory = class OpraApiFactory {
                 continue;
             resources.push(instance);
             /* Wrap resolver functions */
-            const prototype = Object.getPrototypeOf(instance);
             const isRequestScoped = !wrapper.isDependencyTreeStatic();
             // 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')
+                for (const methodName of Object.keys(resourceDef.operations)) {
+                    const operationFunction = instance[methodName];
+                    const nestHandlerName = methodName + '_nestjs';
+                    // Skip patch if controller do not have function for operation or already patched before
+                    if (typeof operationFunction !== '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 paramArgsMetadata = Reflect.getMetadata(constants_js_1.PARAM_ARGS_METADATA, instance.constructor, methodName);
                     const hasParamsArgs = !!paramArgsMetadata;
-                    const patchedFn = prototype[nestHandlerName] = function (...args) {
+                    const patchedFn = instance[nestHandlerName] = function (...args) {
                         if (hasParamsArgs)
-                            return fn.apply(this, args);
-                        return fn.call(this, args[3]);
+                            return operationFunction.apply(this, args);
+                        return operationFunction.call(this, args[3]);
                     };
                     if (paramArgsMetadata)
                         Reflect.defineMetadata(constants_js_1.PARAM_ARGS_METADATA, paramArgsMetadata, instance.constructor, nestHandlerName);
                     // Copy all metadata from old Function to new one
-                    Reflect.getMetadataKeys(fn).forEach(k => {
-                        const m = Reflect.getMetadata(k, fn);
+                    Reflect.getMetadataKeys(operationFunction).forEach(k => {
+                        const m = Reflect.getMetadata(k, operationFunction);
                         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
-                    });
+                    this._createContextCallback(instance, wrapper, rootModule, methodName, isRequestScoped, contextType);
                 }
             }
         }
         // Create api document
         return common_2.DocumentFactory.createDocument(apiSchema);
     }
-    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = lodash_identity_1.default, contextType, options) {
+    _createHandler(instance, callback) {
+        return function (ctx) {
+            switch (ctx.protocol) {
+                case 'http':
+                    const httpContext = ctx.switchToHttp();
+                    return callback(httpContext.incoming, httpContext.outgoing, noOpFunction, ctx);
+                default:
+                    throw new Error(`"${ctx.protocol}" context type is not implemented yet`);
+            }
+        };
+    }
+    _createContextCallback(instance, wrapper, moduleRef, methodName, isRequestScoped, contextType, options) {
         const paramsFactory = this.paramsFactory;
-        if (isRequestScoped) {
-            return async (...args) => {
+        const nestHandlerName = methodName + '_nestjs';
+        const callback = isRequestScoped
+            ? async (...args) => {
                 const opraContext = paramsFactory.exchangeKeyForValue(handler_paramtype_enum_js_1.HandlerParamType.CONTEXT, undefined, args);
                 const contextId = this.getContextId(opraContext);
                 this.registerContextProvider(opraContext, contextId);
                 const contextInstance = await this.injector.loadPerContext(instance, moduleRef, moduleRef.providers, contextId);
-                const 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[methodName], methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
+                const contextCallback = this.externalContextCreator.create(contextInstance, contextInstance[methodName], nestHandlerName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
+                contextInstance[methodName] = this._createHandler(instance, contextCallback);
+                return contextCallback(...args);
+            }
+            : this.externalContextCreator.create(instance, instance[nestHandlerName], nestHandlerName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
+        instance[methodName] = this._createHandler(instance, callback);
+        return callback;
     }
     // noinspection JSMethodCanBeStatic
     getContextId(gqlContext) {

package/cjs/factories/params.factory.js

@@ -11,8 +11,6 @@ class OpraParamsFactory {
         switch (type) {
             case handler_paramtype_enum_js_1.HandlerParamType.CONTEXT:
                 return args[3];
-            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:

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

@@ -17,11 +17,13 @@ class OpraApiLoader {
         const globalPrefix = this.applicationConfig.getGlobalPrefix();
         const platformName = httpAdapter.getType();
         const moduleOptions = this.opraModuleOptions;
-        const prefix = '/' + (0, common_2.normalizePath)((0, common_2.joinPath)((moduleOptions.useGlobalPrefix !== false ? globalPrefix : ''), moduleOptions.prefix || ''), true);
+        let prefixPath = new common_2.OpraURLPath((moduleOptions.useGlobalPrefix !== false ? globalPrefix : ''));
+        if (moduleOptions.basePath)
+            prefixPath = prefixPath.join(moduleOptions.basePath);
         const name = moduleOptions.info?.title || 'untitled service';
         const options = {
             ...moduleOptions,
-            prefix
+            basePath: prefixPath.toString()
         };
         try {
             const serviceHost = await this.opraFactory.generateService(rootModule, options, 'http');
@@ -37,7 +39,7 @@ class OpraApiLoader {
             else { // noinspection ExceptionCaughtLocallyJS
                 throw new Error(`No support for current HttpAdapter: ${platformName}`);
             }
-            this.logger.log(`Mapped {${prefix}} to "${name}" service`);
+            this.logger.log(`Mapped {${prefixPath.toString() || '/'}} to "${name}" service`);
         }
         catch (e) {
             this.logger.error(e);
@@ -52,14 +54,10 @@ class OpraApiLoader {
         if (!httpAdapter)
             return;
         const app = httpAdapter.getInstance();
-        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, {
+        const logger = moduleOptions.logger || new common_1.Logger(service.info.title);
+        return await core_2.ExpressAdapter.create(app, service, {
+            ...moduleOptions,
             logger,
-            ...moduleOptions
         });
     }
 }

package/esm/decorators/context.decorator.js

@@ -5,8 +5,3 @@ 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 `OpraService`.
- */
-export const ApiDoc = createOpraParamDecorator(HandlerParamType.API);

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

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

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

@@ -1,6 +1,5 @@
 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';
@@ -50,70 +49,68 @@ export let OpraApiFactory = class OpraApiFactory {
                 continue;
             resources.push(instance);
             /* Wrap resolver functions */
-            const prototype = Object.getPrototypeOf(instance);
             const isRequestScoped = !wrapper.isDependencyTreeStatic();
             // 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')
+                for (const methodName of Object.keys(resourceDef.operations)) {
+                    const operationFunction = instance[methodName];
+                    const nestHandlerName = methodName + '_nestjs';
+                    // Skip patch if controller do not have function for operation or already patched before
+                    if (typeof operationFunction !== '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 paramArgsMetadata = Reflect.getMetadata(PARAM_ARGS_METADATA, instance.constructor, methodName);
                     const hasParamsArgs = !!paramArgsMetadata;
-                    const patchedFn = prototype[nestHandlerName] = function (...args) {
+                    const patchedFn = instance[nestHandlerName] = function (...args) {
                         if (hasParamsArgs)
-                            return fn.apply(this, args);
-                        return fn.call(this, args[3]);
+                            return operationFunction.apply(this, args);
+                        return operationFunction.call(this, args[3]);
                     };
                     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 m = Reflect.getMetadata(k, fn);
+                    Reflect.getMetadataKeys(operationFunction).forEach(k => {
+                        const m = Reflect.getMetadata(k, operationFunction);
                         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
-                    });
+                    this._createContextCallback(instance, wrapper, rootModule, methodName, isRequestScoped, contextType);
                 }
             }
         }
         // Create api document
         return DocumentFactory.createDocument(apiSchema);
     }
-    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = identity, contextType, options) {
+    _createHandler(instance, callback) {
+        return function (ctx) {
+            switch (ctx.protocol) {
+                case 'http':
+                    const httpContext = ctx.switchToHttp();
+                    return callback(httpContext.incoming, httpContext.outgoing, noOpFunction, ctx);
+                default:
+                    throw new Error(`"${ctx.protocol}" context type is not implemented yet`);
+            }
+        };
+    }
+    _createContextCallback(instance, wrapper, moduleRef, methodName, isRequestScoped, contextType, options) {
         const paramsFactory = this.paramsFactory;
-        if (isRequestScoped) {
-            return async (...args) => {
+        const nestHandlerName = methodName + '_nestjs';
+        const callback = isRequestScoped
+            ? 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[methodName]), methodName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
-                return callback(...args);
-            };
-        }
-        return this.externalContextCreator.create(instance, prototype[methodName], methodName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
+                const contextCallback = this.externalContextCreator.create(contextInstance, contextInstance[methodName], nestHandlerName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
+                contextInstance[methodName] = this._createHandler(instance, contextCallback);
+                return contextCallback(...args);
+            }
+            : this.externalContextCreator.create(instance, instance[nestHandlerName], nestHandlerName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
+        instance[methodName] = this._createHandler(instance, callback);
+        return callback;
     }
     // noinspection JSMethodCanBeStatic
     getContextId(gqlContext) {

package/esm/factories/params.factory.js

@@ -8,8 +8,6 @@ export class OpraParamsFactory {
         switch (type) {
             case HandlerParamType.CONTEXT:
                 return args[3];
-            case HandlerParamType.API:
-                return args[3].api;
             case HandlerParamType.REQUEST:
                 return args[3].request;
             case HandlerParamType.RESPONSE:

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

@@ -1,8 +1,8 @@
 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 { OpraURLPath } from '@opra/common';
+import { ExpressAdapter } from '@opra/core';
 import { OPRA_MODULE_OPTIONS } from '../constants.js';
 import { OpraApiFactory } from '../factories/opra-api.factory.js';
 export class OpraApiLoader {
@@ -14,11 +14,13 @@ export class OpraApiLoader {
         const globalPrefix = this.applicationConfig.getGlobalPrefix();
         const platformName = httpAdapter.getType();
         const moduleOptions = this.opraModuleOptions;
-        const prefix = '/' + normalizePath(joinPath((moduleOptions.useGlobalPrefix !== false ? globalPrefix : ''), moduleOptions.prefix || ''), true);
+        let prefixPath = new OpraURLPath((moduleOptions.useGlobalPrefix !== false ? globalPrefix : ''));
+        if (moduleOptions.basePath)
+            prefixPath = prefixPath.join(moduleOptions.basePath);
         const name = moduleOptions.info?.title || 'untitled service';
         const options = {
             ...moduleOptions,
-            prefix
+            basePath: prefixPath.toString()
         };
         try {
             const serviceHost = await this.opraFactory.generateService(rootModule, options, 'http');
@@ -34,7 +36,7 @@ export class OpraApiLoader {
             else { // noinspection ExceptionCaughtLocallyJS
                 throw new Error(`No support for current HttpAdapter: ${platformName}`);
             }
-            this.logger.log(`Mapped {${prefix}} to "${name}" service`);
+            this.logger.log(`Mapped {${prefixPath.toString() || '/'}} to "${name}" service`);
         }
         catch (e) {
             this.logger.error(e);
@@ -49,14 +51,10 @@ export class OpraApiLoader {
         if (!httpAdapter)
             return;
         const app = httpAdapter.getInstance();
-        let logger = moduleOptions.logger;
-        if (!logger) {
-            logger = new Logger(service.info.title);
-            logger.fatal = logger.error.bind(logger);
-        }
-        return OpraExpressAdapter.create(app, service, {
+        const logger = moduleOptions.logger || new Logger(service.info.title);
+        return await ExpressAdapter.create(app, service, {
+            ...moduleOptions,
             logger,
-            ...moduleOptions
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/nestjs",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
@@ -25,8 +25,8 @@
     "clean:cover": "rimraf ../../coverage/nestjs"
   },
   "dependencies": {
-    "@opra/common": "^0.22.0",
-    "@opra/core": "^0.22.0",
+    "@opra/common": "^0.23.0",
+    "@opra/core": "^0.23.0",
     "fast-tokenizer": "^1.2.2",
     "lodash.head": "^4.0.1",
     "lodash.identity": "^3.0.0",
@@ -39,7 +39,8 @@
     "@nestjs/platform-express": "^10.1.0",
     "@nestjs/testing": "^10.1.0",
     "@types/lodash": "^4.14.195",
-    "filedirname": "^2.7.0"
+    "filedirname": "^2.7.0",
+    "ts-gems": "^2.4.1"
   },
   "type": "module",
   "types": "types/index.d.ts",

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

@@ -3,8 +3,3 @@
  * 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

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

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

@@ -9,6 +9,7 @@ export declare class OpraApiFactory {
     private readonly externalContextCreator;
     private readonly explorerService;
     generateService(rootModule: Module, moduleOptions: OpraModuleOptions, contextType: ContextType): Promise<ApiDocument>;
+    private _createHandler;
     private _createContextCallback;
     private getContextId;
     private registerContextProvider;

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

@@ -1,7 +1,7 @@
 import { ModuleMetadata, Type } from '@nestjs/common';
 import { OpraSchema } from '@opra/common';
-import { OpraHttpAdapter } from '@opra/core';
-export type OpraModuleOptions = OpraHttpAdapter.Options & {
+import { HttpAdapter } from '@opra/core';
+export type OpraModuleOptions = HttpAdapter.Options & {
     info?: OpraSchema.DocumentInfo;
     /**
      * @default true

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

@@ -1,17 +1,18 @@
+import { Logger } from '@nestjs/common';
 import { ApplicationConfig, HttpAdapterHost } from '@nestjs/core';
 import { Module } from '@nestjs/core/injector/module.js';
 import { ApiDocument } from '@opra/common';
-import { OpraExpressAdapter } from '@opra/core';
+import { ExpressAdapter, PlatformAdapter } from '@opra/core';
 import { OpraApiFactory } from '../factories/opra-api.factory.js';
 import { OpraModuleOptions } from '../interfaces/opra-module-options.interface.js';
 export declare class OpraApiLoader {
-    private readonly logger;
-    private adapter;
+    protected readonly logger: Logger;
+    protected adapter: PlatformAdapter | undefined;
     protected readonly httpAdapterHost: HttpAdapterHost;
     protected readonly applicationConfig: ApplicationConfig;
     protected readonly opraFactory: OpraApiFactory;
     protected readonly opraModuleOptions: OpraModuleOptions;
     initialize(rootModule: Module): Promise<void>;
     stop(): Promise<void>;
-    protected registerExpress(service: ApiDocument, moduleOptions: OpraModuleOptions): Promise<OpraExpressAdapter | undefined>;
+    protected registerExpress(service: ApiDocument, moduleOptions: OpraModuleOptions): Promise<ExpressAdapter | undefined>;
 }