@opra/nestjs 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# OPRA
+Open Protocol for Restful Api

package/cjs/constants.js

@@ -0,0 +1,7 @@
+"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/cjs/decorators/context.decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = exports.Service = exports.Response = exports.Request = 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 `ExecutionContext`.
+ */
+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 `ExecutionRequest`.
+ */
+exports.Request = (0, param_utils_js_1.createOpraParamDecorator)(handler_paramtype_enum_js_1.HandlerParamType.REQUEST);
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `ExecutionResponse`.
+ */
+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);

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

@@ -0,0 +1,12 @@
+"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["REQUEST"] = 2] = "REQUEST";
+    HandlerParamType[HandlerParamType["QUERY"] = 3] = "QUERY";
+    HandlerParamType[HandlerParamType["RESPONSE"] = 4] = "RESPONSE";
+    HandlerParamType[HandlerParamType["USER_CONTEXT"] = 5] = "USER_CONTEXT";
+})(HandlerParamType = exports.HandlerParamType || (exports.HandlerParamType = {}));

package/cjs/factories/params.factory.js

@@ -0,0 +1,29 @@
+"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 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.REQUEST:
+                return args[3].request;
+            case handler_paramtype_enum_js_1.HandlerParamType.QUERY:
+                return args[3].request.query;
+            case handler_paramtype_enum_js_1.HandlerParamType.RESPONSE:
+                return args[3].response;
+            case handler_paramtype_enum_js_1.HandlerParamType.USER_CONTEXT:
+                return args[3].userContext;
+            default:
+                return null;
+        }
+    }
+}
+exports.OpraParamsFactory = OpraParamsFactory;

package/cjs/factories/service.factory.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceFactory = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+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 core_2 = require("@opra/core");
+const schema_1 = require("@opra/schema");
+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 entityHandlers = ['search', 'create', 'read', 'update', 'updateMany', 'delete', 'deleteMany'];
+const noOpFunction = () => void 0;
+let ServiceFactory = class ServiceFactory {
+    paramsFactory = new params_factory_js_1.OpraParamsFactory();
+    injector = new injector_1.Injector();
+    modulesContainer;
+    externalContextCreator;
+    explorerService;
+    async generateService(rootModule, moduleOptions, contextType) {
+        const info = { title: '', version: '', ...moduleOptions.info };
+        info.title = info.title || 'Untitled service';
+        info.version = info.version || '1';
+        const serviceArgs = {
+            info,
+            types: [],
+            resources: [],
+        };
+        const wrappers = this.explorerService.exploreResourceWrappers(rootModule);
+        for (const wrapper of wrappers) {
+            const instance = wrapper.instance;
+            const resourceDef = Reflect.getMetadata(core_2.RESOURCE_METADATA, instance.constructor);
+            /* istanbul ignore next */
+            if (!resourceDef)
+                continue;
+            serviceArgs.resources.push(instance);
+            /* Wrap resolver functions */
+            const prototype = Object.getPrototypeOf(instance);
+            const isRequestScoped = !wrapper.isDependencyTreeStatic();
+            if (schema_1.OpraSchema.isEntityResource(resourceDef)) {
+                for (const x of entityHandlers) {
+                    const fn = instance[x];
+                    if (typeof fn === 'function') {
+                        const methodName = fn.name || x;
+                        const callback = this._createContextCallback(instance, prototype, wrapper, rootModule, methodName, isRequestScoped, undefined, contextType);
+                        const newFn = instance[x] = (ctx) => {
+                            switch (ctx.type) {
+                                case 'http':
+                                    const http = ctx.switchToHttp();
+                                    return callback(http.getRequest().getInstance(), http.getResponse().getInstance(), noOpFunction, ctx);
+                                default:
+                                    throw new Error(`"${ctx.type}" context type is not implemented yet`);
+                            }
+                        };
+                        if (methodName && newFn.name !== methodName)
+                            Object.defineProperty(newFn, 'name', {
+                                configurable: false,
+                                writable: false,
+                                enumerable: true,
+                                value: methodName
+                            });
+                    }
+                }
+            }
+        }
+        return await core_2.OpraService.create(serviceArgs);
+    }
+    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = lodash_1.default.identity, contextType) {
+        const paramsFactory = this.paramsFactory;
+        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[methodName]), methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, undefined, // contextOptions
+                opraContext.type);
+                return callback(...args);
+            };
+        }
+        return this.externalContextCreator.create(instance, prototype[methodName], methodName, constants_js_1.PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, undefined, // contextOptions
+        contextType);
+    }
+    // noinspection JSMethodCanBeStatic
+    getContextId(gqlContext) {
+        const numberOfArguments = (0, function_utils_js_1.getNumberOfArguments)(core_1.ContextIdFactory.getByRequest);
+        if (numberOfArguments === 2) {
+            // @ts-ignore
+            const contextId = core_1.ContextIdFactory.getByRequest(gqlContext, ['req']);
+            if (!gqlContext[request_constants_1.REQUEST_CONTEXT_ID]) {
+                Object.defineProperty(gqlContext, request_constants_1.REQUEST_CONTEXT_ID, {
+                    value: contextId,
+                    enumerable: false,
+                    configurable: false,
+                    writable: false,
+                });
+            }
+            return contextId;
+        }
+        else {
+            // TODO remove in the next version (backward-compatibility layer)
+            // Left for backward compatibility purposes
+            let contextId;
+            if (gqlContext && gqlContext[request_constants_1.REQUEST_CONTEXT_ID]) {
+                contextId = gqlContext[request_constants_1.REQUEST_CONTEXT_ID];
+            }
+            else if (gqlContext &&
+                gqlContext.req &&
+                gqlContext.req[request_constants_1.REQUEST_CONTEXT_ID]) {
+                contextId = gqlContext.req[request_constants_1.REQUEST_CONTEXT_ID];
+            }
+            else {
+                contextId = (0, core_1.createContextId)();
+                Object.defineProperty(gqlContext, request_constants_1.REQUEST_CONTEXT_ID, {
+                    value: contextId,
+                    enumerable: false,
+                    configurable: false,
+                    writable: false,
+                });
+            }
+            return contextId;
+        }
+    }
+    registerContextProvider(request, contextId) {
+        const coreModuleArray = [...this.modulesContainer.entries()]
+            .filter(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ([key, { metatype }]) => metatype && metatype.name === internal_core_module_1.InternalCoreModule.name)
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            .map(([key, value]) => value);
+        const coreModuleRef = lodash_1.default.head(coreModuleArray);
+        if (!coreModuleRef) {
+            return;
+        }
+        const wrapper = coreModuleRef.getProviderByKey(core_1.REQUEST);
+        wrapper.setInstanceByContextId(contextId, {
+            instance: request,
+            isResolved: true,
+        });
+    }
+};
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", core_1.ModulesContainer)
+], ServiceFactory.prototype, "modulesContainer", void 0);
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", external_context_creator_1.ExternalContextCreator)
+], ServiceFactory.prototype, "externalContextCreator", void 0);
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", nest_explorer_js_1.NestExplorer)
+], ServiceFactory.prototype, "explorerService", void 0);
+ServiceFactory = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], ServiceFactory);
+exports.ServiceFactory = ServiceFactory;

package/cjs/index.js

@@ -0,0 +1,9 @@
+"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-execution-context.js"), exports);
+tslib_1.__exportStar(require("./interfaces/opra-module-options.interface.js"), exports);
+// export * as Api from './decorators/api.ns.js';

package/cjs/interfaces/opra-execution-context.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraExecutionContext = void 0;
+var OpraExecutionContext;
+(function (OpraExecutionContext) {
+    function from(source) {
+        return source.getArgByIndex(4);
+    }
+    OpraExecutionContext.from = from;
+})(OpraExecutionContext = exports.OpraExecutionContext || (exports.OpraExecutionContext = {}));

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

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

package/cjs/opra-core.module.js

@@ -0,0 +1,149 @@
+"use strict";
+var OpraCoreModule_1;
+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 i18n_1 = require("@opra/i18n");
+const constants_js_1 = require("./constants.js");
+const service_factory_js_1 = require("./factories/service.factory.js");
+const nest_explorer_js_1 = require("./services/nest-explorer.js");
+const service_loader_js_1 = require("./services/service-loader.js");
+let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
+    httpAdapterHost;
+    modulesContainer;
+    options;
+    opraServiceLoader;
+    constructor(httpAdapterHost, modulesContainer, options, opraServiceLoader) {
+        this.httpAdapterHost = httpAdapterHost;
+        this.modulesContainer = modulesContainer;
+        this.options = options;
+        this.opraServiceLoader = opraServiceLoader;
+    }
+    static forRoot(options) {
+        return {
+            module: OpraCoreModule_1,
+            imports: [...(options.imports || [])],
+            providers: [
+                ...(options.providers || []),
+                {
+                    provide: constants_js_1.OPRA_MODULE_OPTIONS,
+                    useValue: options,
+                },
+                {
+                    provide: constants_js_1.OPRA_INITIALIZER,
+                    useClass: service_loader_js_1.OpraServiceLoader
+                },
+                this.createI18nProvider()
+            ],
+            exports: [...(options.exports || [])]
+        };
+    }
+    static forRootAsync(asyncOptions) {
+        return {
+            module: OpraCoreModule_1,
+            imports: [...(asyncOptions.imports || [])],
+            providers: [
+                ...(asyncOptions.providers || []),
+                {
+                    provide: constants_js_1.OPRA_MODULE_ID,
+                    useValue: crypto.randomUUID()
+                },
+                {
+                    provide: constants_js_1.OPRA_INITIALIZER,
+                    useClass: service_loader_js_1.OpraServiceLoader
+                },
+                ...this.createAsyncProviders(asyncOptions),
+                this.createI18nProvider(),
+            ]
+        };
+    }
+    static createI18nProvider() {
+        return {
+            provide: i18n_1.I18n,
+            inject: [constants_js_1.OPRA_MODULE_OPTIONS],
+            useFactory: async (options) => {
+                const opts = options.i18n;
+                const initOptions = {
+                    lng: opts?.lng,
+                    fallbackLng: opts?.fallbackLng,
+                    defaultNS: opts?.defaultNS,
+                    resources: opts?.resources,
+                    resourceDirs: opts?.resourceDirs
+                };
+                const instance = i18n_1.I18n.createInstance();
+                await instance.init(initOptions);
+                return instance;
+            }
+        };
+    }
+    static createAsyncProviders(asyncOptions) {
+        if (asyncOptions.useExisting || asyncOptions.useFactory)
+            return [this.createAsyncOptionsProvider(asyncOptions)];
+        if (asyncOptions.useClass)
+            return [
+                this.createAsyncOptionsProvider(asyncOptions),
+                {
+                    provide: asyncOptions.useClass,
+                    useClass: asyncOptions.useClass
+                }
+            ];
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    static createAsyncOptionsProvider(asyncOptions) {
+        if (asyncOptions.useFactory) {
+            return {
+                provide: constants_js_1.OPRA_MODULE_OPTIONS,
+                useFactory: asyncOptions.useFactory,
+                inject: asyncOptions.inject || []
+            };
+        }
+        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
+        if (useClass) {
+            return {
+                provide: constants_js_1.OPRA_MODULE_OPTIONS,
+                useFactory: (optionsFactory) => optionsFactory.createOptions(),
+                inject: [useClass]
+            };
+        }
+        throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    }
+    async onModuleInit() {
+        const httpAdapter = this.httpAdapterHost?.httpAdapter;
+        if (!httpAdapter)
+            return;
+        const opraModule = (() => {
+            for (const m of this.modulesContainer.values()) {
+                for (const imp of m.imports.values()) {
+                    for (const prv of imp.providers.values())
+                        if (prv.instance === this) {
+                            return imp;
+                        }
+                }
+            }
+        })();
+        if (opraModule) {
+            await this.opraServiceLoader.initialize(opraModule);
+        }
+    }
+    async onModuleDestroy() {
+        await this.opraServiceLoader.stop();
+    }
+};
+OpraCoreModule = OpraCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [
+            service_factory_js_1.ServiceFactory,
+            metadata_scanner_1.MetadataScanner,
+            nest_explorer_js_1.NestExplorer
+        ]
+    }),
+    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, service_loader_js_1.OpraServiceLoader])
+], OpraCoreModule);
+exports.OpraCoreModule = OpraCoreModule;

package/cjs/opra.module.js

@@ -0,0 +1,25 @@
+"use strict";
+var OpraModule_1;
+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: [opra_core_module_js_1.OpraCoreModule.forRoot(options)]
+        };
+    }
+    static forRootAsync(asyncOptions) {
+        return {
+            module: OpraModule_1,
+            imports: [opra_core_module_js_1.OpraCoreModule.forRootAsync(asyncOptions)]
+        };
+    }
+};
+OpraModule = OpraModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], OpraModule);
+exports.OpraModule = OpraModule;

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/services/nest-explorer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestExplorer = void 0;
+const core_1 = require("@opra/core");
+class NestExplorer {
+    exploreProviders(rootModule, predicate) {
+        const modules = new Set();
+        const wrappers = new Set();
+        const scanModules = (m) => {
+            if (modules.has(m))
+                return;
+            modules.add(m);
+            for (const mm of m.imports.values()) {
+                scanModules(mm);
+            }
+            for (const wrapper of m.providers.values()) {
+                if (!wrappers.has(wrapper) && predicate(wrapper))
+                    wrappers.add(wrapper);
+                if (wrapper.host)
+                    scanModules(wrapper.host);
+            }
+        };
+        scanModules(rootModule);
+        return Array.from(wrappers.values());
+    }
+    exploreResourceWrappers(rootModule) {
+        return this.exploreProviders(rootModule, (wrapper) => {
+            return !!(wrapper.instance
+                && typeof wrapper.instance === 'object'
+                && wrapper.instance.constructor
+                && Reflect.hasMetadata(core_1.RESOURCE_METADATA, wrapper.instance.constructor));
+        });
+    }
+}
+exports.NestExplorer = NestExplorer;

package/cjs/services/service-loader.js

@@ -0,0 +1,88 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraServiceLoader = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const core_2 = require("@opra/core");
+const i18n_1 = require("@opra/i18n");
+const url_1 = require("@opra/url");
+const constants_js_1 = require("../constants.js");
+const service_factory_js_1 = require("../factories/service.factory.js");
+class OpraServiceLoader {
+    logger = new common_1.Logger(OpraServiceLoader.name, { timestamp: true });
+    adapter;
+    httpAdapterHost;
+    applicationConfig;
+    opraFactory;
+    opraModuleOptions;
+    i18n;
+    async initialize(rootModule) {
+        const httpAdapter = this.httpAdapterHost?.httpAdapter;
+        const globalPrefix = this.applicationConfig.getGlobalPrefix();
+        const platformName = httpAdapter.getType();
+        const moduleOptions = this.opraModuleOptions;
+        const prefix = '/' + (0, url_1.normalizePath)((0, url_1.joinPath)((moduleOptions.useGlobalPrefix !== false ? globalPrefix : ''), moduleOptions.prefix || ''), true);
+        const name = moduleOptions.info?.title || 'untitled service';
+        const options = {
+            ...moduleOptions,
+            prefix
+        };
+        try {
+            const serviceHost = await this.opraFactory.generateService(rootModule, options, 'http');
+            if (!Object.keys(serviceHost.resources).length) {
+                this.logger.warn(`No resources found (${name})`);
+                return;
+            }
+            // serviceConfiguration.i18n = this.i18n;
+            if (platformName === 'express') {
+                this.adapter = await this.registerExpress(serviceHost, options);
+                // else if (platformName === 'fastify')
+                // await this.registerFastify();
+            }
+            else { // noinspection ExceptionCaughtLocallyJS
+                throw new Error(`No support for current HttpAdapter: ${platformName}`);
+            }
+            this.logger.log(`Mapped {${prefix}} to "${name}" service`);
+        }
+        catch (e) {
+            this.logger.error(e);
+            throw e;
+        }
+    }
+    async stop() {
+        //
+    }
+    async registerExpress(service, moduleOptions) {
+        const httpAdapter = this.httpAdapterHost.httpAdapter;
+        if (!httpAdapter)
+            return;
+        const app = httpAdapter.getInstance();
+        return core_2.OpraExpressAdapter.init(app, service, {
+            i18n: this.i18n,
+            prefix: moduleOptions.prefix
+        });
+    }
+}
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", core_1.HttpAdapterHost)
+], OpraServiceLoader.prototype, "httpAdapterHost", void 0);
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", core_1.ApplicationConfig)
+], OpraServiceLoader.prototype, "applicationConfig", void 0);
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", service_factory_js_1.ServiceFactory)
+], OpraServiceLoader.prototype, "opraFactory", void 0);
+tslib_1.__decorate([
+    (0, common_1.Inject)(constants_js_1.OPRA_MODULE_OPTIONS),
+    tslib_1.__metadata("design:type", Object)
+], OpraServiceLoader.prototype, "opraModuleOptions", void 0);
+tslib_1.__decorate([
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", typeof (_a = typeof i18n_1.I18n !== "undefined" && i18n_1.I18n) === "function" ? _a : Object)
+], OpraServiceLoader.prototype, "i18n", void 0);
+exports.OpraServiceLoader = OpraServiceLoader;

package/cjs/types.js

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

package/cjs/utils/class.utils.js

@@ -0,0 +1,25 @@
+"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);
+}
+exports.isConstructor = isConstructor;
+function getClassOrUndefined(typeOrFunc) {
+    return isConstructor(typeOrFunc)
+        ? typeOrFunc
+        : (0, shared_utils_1.isFunction)(typeOrFunc)
+            ? typeOrFunc()
+            : undefined;
+}
+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/cjs/utils/function.utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNumberOfArguments = void 0;
+const fast_tokenizer_1 = require("fast-tokenizer");
+const anythingEnclosedInParenthesesRegex = /\((.+)\)/;
+function getNumberOfArguments(fn) {
+    const functionAsString = fn.toString();
+    const parametersEnclosedInParentheses = functionAsString.match(anythingEnclosedInParenthesesRegex);
+    if (parametersEnclosedInParentheses) {
+        const matchString = parametersEnclosedInParentheses[1];
+        const argumentsArray = (0, fast_tokenizer_1.splitString)(matchString, {
+            brackets: {
+                '(': ')',
+                '{': '}',
+                '[': ']',
+                '/*': '*/'
+            }, delimiters: ','
+        });
+        return argumentsArray.length;
+    }
+    return 0;
+}
+exports.getNumberOfArguments = getNumberOfArguments;