@opra/nestjs 0.0.5

package/cjs/utils/param.utils.js

@@ -0,0 +1,22 @@
+"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,
+        [`${paramType}:${index}`]: {
+            index,
+            data,
+            pipes,
+        },
+    };
+}
+function createOpraParamDecorator(paramType) {
+    return (target, key, index) => {
+        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/esm/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const OPRA_MODULE_OPTIONS = "opra:module_options";
+export declare const OPRA_MODULE_ID = "opra:module_id";
+export declare const OPRA_INITIALIZER = "opra_initializer";
+export declare const PARAM_ARGS_METADATA = "__routeArguments__";

package/esm/constants.js

@@ -0,0 +1,4 @@
+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__';

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

@@ -0,0 +1,25 @@
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `ExecutionContext`.
+ */
+export declare const Context: ParameterDecorator;
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `ExecutionRequest`.
+ */
+export declare const Request: ParameterDecorator;
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `ExecutionResponse`.
+ */
+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/decorators/context.decorator.js

@@ -0,0 +1,27 @@
+import { HandlerParamType } from '../enums/handler-paramtype.enum.js';
+import { createOpraParamDecorator } from '../utils/param.utils.js';
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `ExecutionContext`.
+ */
+export const Context = createOpraParamDecorator(HandlerParamType.CONTEXT);
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `ExecutionRequest`.
+ */
+export const Request = createOpraParamDecorator(HandlerParamType.REQUEST);
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `ExecutionResponse`.
+ */
+export const Response = createOpraParamDecorator(HandlerParamType.RESPONSE);
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `OpraService`.
+ */
+export const Service = createOpraParamDecorator(HandlerParamType.SERVICE);
+/**
+ * Handler method parameter decorator. Populates the decorated
+ * parameter with the value of `OpraService`.
+ */
+export const Query = createOpraParamDecorator(HandlerParamType.QUERY);

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

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

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

@@ -0,0 +1,9 @@
+export 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 || (HandlerParamType = {}));

package/esm/factories/params.factory.d.ts

@@ -0,0 +1,4 @@
+import { ParamsFactory } from '@nestjs/core/helpers/external-context-creator.js';
+export declare class OpraParamsFactory implements ParamsFactory {
+    exchangeKeyForValue(type: number, data: any, args: any): any;
+}

package/esm/factories/params.factory.js

@@ -0,0 +1,25 @@
+import { HandlerParamType } from '../enums/handler-paramtype.enum.js';
+export class OpraParamsFactory {
+    exchangeKeyForValue(type, data, args) {
+        if (!args) {
+            return null;
+        }
+        args = Array.isArray(args) ? args : [];
+        switch (type) {
+            case HandlerParamType.CONTEXT:
+                return args[3];
+            case HandlerParamType.SERVICE:
+                return args[3].service;
+            case HandlerParamType.REQUEST:
+                return args[3].request;
+            case HandlerParamType.QUERY:
+                return args[3].request.query;
+            case HandlerParamType.RESPONSE:
+                return args[3].response;
+            case HandlerParamType.USER_CONTEXT:
+                return args[3].userContext;
+            default:
+                return null;
+        }
+    }
+}

package/esm/factories/service.factory.d.ts

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

package/esm/factories/service.factory.js

@@ -0,0 +1,161 @@
+import { __decorate, __metadata } from "tslib";
+import _ from 'lodash';
+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 { OpraService, RESOURCE_METADATA } from '@opra/core';
+import { OpraSchema } from '@opra/schema';
+import { PARAM_ARGS_METADATA } from '../constants.js';
+import { HandlerParamType } from '../enums/handler-paramtype.enum.js';
+import { NestExplorer } from '../services/nest-explorer.js';
+import { getNumberOfArguments } from '../utils/function.utils.js';
+import { OpraParamsFactory } from './params.factory.js';
+const entityHandlers = ['search', 'create', 'read', 'update', 'updateMany', 'delete', 'deleteMany'];
+const noOpFunction = () => void 0;
+let ServiceFactory = class ServiceFactory {
+    paramsFactory = new OpraParamsFactory();
+    injector = new 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(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 (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 OpraService.create(serviceArgs);
+    }
+    _createContextCallback(instance, prototype, wrapper, moduleRef, methodName, isRequestScoped, transform = _.identity, contextType) {
+        const paramsFactory = this.paramsFactory;
+        if (isRequestScoped) {
+            return async (...args) => {
+                const opraContext = paramsFactory.exchangeKeyForValue(HandlerParamType.CONTEXT, undefined, args);
+                const contextId = this.getContextId(opraContext);
+                this.registerContextProvider(opraContext, contextId);
+                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, moduleRef.providers, contextId);
+                const callback = this.externalContextCreator.create(contextInstance, transform(contextInstance[methodName]), methodName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, undefined, // contextOptions
+                opraContext.type);
+                return callback(...args);
+            };
+        }
+        return this.externalContextCreator.create(instance, prototype[methodName], methodName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, undefined, // contextOptions
+        contextType);
+    }
+    // noinspection JSMethodCanBeStatic
+    getContextId(gqlContext) {
+        const numberOfArguments = getNumberOfArguments(ContextIdFactory.getByRequest);
+        if (numberOfArguments === 2) {
+            // @ts-ignore
+            const contextId = ContextIdFactory.getByRequest(gqlContext, ['req']);
+            if (!gqlContext[REQUEST_CONTEXT_ID]) {
+                Object.defineProperty(gqlContext, 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_CONTEXT_ID]) {
+                contextId = gqlContext[REQUEST_CONTEXT_ID];
+            }
+            else if (gqlContext &&
+                gqlContext.req &&
+                gqlContext.req[REQUEST_CONTEXT_ID]) {
+                contextId = gqlContext.req[REQUEST_CONTEXT_ID];
+            }
+            else {
+                contextId = createContextId();
+                Object.defineProperty(gqlContext, 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 === InternalCoreModule.name)
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            .map(([key, value]) => value);
+        const coreModuleRef = _.head(coreModuleArray);
+        if (!coreModuleRef) {
+            return;
+        }
+        const wrapper = coreModuleRef.getProviderByKey(REQUEST);
+        wrapper.setInstanceByContextId(contextId, {
+            instance: request,
+            isResolved: true,
+        });
+    }
+};
+__decorate([
+    Inject(),
+    __metadata("design:type", ModulesContainer)
+], ServiceFactory.prototype, "modulesContainer", void 0);
+__decorate([
+    Inject(),
+    __metadata("design:type", ExternalContextCreator)
+], ServiceFactory.prototype, "externalContextCreator", void 0);
+__decorate([
+    Inject(),
+    __metadata("design:type", NestExplorer)
+], ServiceFactory.prototype, "explorerService", void 0);
+ServiceFactory = __decorate([
+    Injectable()
+], ServiceFactory);
+export { ServiceFactory };

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export * from './opra.module.js';
+export * from './decorators/context.decorator.js';
+export * from './interfaces/opra-execution-context.js';
+export * from './interfaces/opra-module-options.interface.js';

package/esm/index.js

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export * from './opra.module.js';
+export * from './decorators/context.decorator.js';
+export * from './interfaces/opra-execution-context.js';
+export * from './interfaces/opra-module-options.interface.js';
+// export * as Api from './decorators/api.ns.js';

package/esm/interfaces/opra-execution-context.d.ts

@@ -0,0 +1,6 @@
+import { ExecutionContext } from '@nestjs/common';
+import * as Opra from '@opra/core';
+export declare type OpraExecutionContext = Opra.ExecutionContext;
+export declare namespace OpraExecutionContext {
+    function from(source: ExecutionContext): OpraExecutionContext;
+}

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

@@ -0,0 +1,7 @@
+export var OpraExecutionContext;
+(function (OpraExecutionContext) {
+    function from(source) {
+        return source.getArgByIndex(4);
+    }
+    OpraExecutionContext.from = from;
+})(OpraExecutionContext || (OpraExecutionContext = {}));

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

@@ -0,0 +1,49 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+import { FallbackLng, LanguageResource } from '@opra/i18n';
+import { OpraSchema } from '@opra/schema';
+export declare type OpraModuleOptions = {
+    /**
+     * @default true
+     */
+    useGlobalPrefix?: boolean;
+    prefix?: string;
+    info?: OpraSchema.DocumentInfo;
+    i18n?: I18nInitOptions;
+    context?: object | ((request: any, platformName: string) => object | Promise<object>);
+};
+export interface I18nInitOptions {
+    /**
+     * Language to use
+     * @default undefined
+     */
+    lng?: string;
+    /**
+     * Language to use if translations in user language are not available.
+     * @default 'dev'
+     */
+    fallbackLng?: false | FallbackLng;
+    /**
+     * Default namespace used if not passed to translation function
+     * @default 'translation'
+     */
+    defaultNS?: string;
+    /**
+     * Resources to initialize with
+     * @default undefined
+     */
+    resources?: LanguageResource;
+    /**
+     * Resource directories to initialize with (if not using loading or not appending using addResourceBundle)
+     * @default undefined
+     */
+    resourceDirs?: string[];
+}
+export interface OpraModuleOptionsFactory {
+    createOptions(): Promise<OpraModuleOptions> | OpraModuleOptions;
+}
+export interface OpraModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'providers'> {
+    useExisting?: Type<OpraModuleOptionsFactory>;
+    useClass?: Type<OpraModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<OpraModuleOptions> | OpraModuleOptions;
+    inject?: any[];
+}

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

@@ -0,0 +1 @@
+export {};

package/esm/opra-core.module.d.ts

@@ -0,0 +1,18 @@
+import { DynamicModule, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { HttpAdapterHost, ModulesContainer } from '@nestjs/core';
+import { OpraModuleAsyncOptions, OpraModuleOptions } from './interfaces/opra-module-options.interface.js';
+import { OpraServiceLoader } from './services/service-loader.js';
+export declare class OpraCoreModule implements OnModuleInit, OnModuleDestroy {
+    private readonly httpAdapterHost;
+    protected readonly modulesContainer: ModulesContainer;
+    private readonly options;
+    private readonly opraServiceLoader;
+    constructor(httpAdapterHost: HttpAdapterHost, modulesContainer: ModulesContainer, options: OpraModuleOptions, opraServiceLoader: OpraServiceLoader);
+    static forRoot(options: OpraModuleOptions & Pick<DynamicModule, 'imports' | 'providers' | 'exports'>): DynamicModule;
+    static forRootAsync(asyncOptions: OpraModuleAsyncOptions): DynamicModule;
+    private static createI18nProvider;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+}

package/esm/opra-core.module.js

@@ -0,0 +1,146 @@
+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 { I18n } from '@opra/i18n';
+import { OPRA_INITIALIZER, OPRA_MODULE_ID, OPRA_MODULE_OPTIONS } from './constants.js';
+import { ServiceFactory } from './factories/service.factory.js';
+import { NestExplorer } from './services/nest-explorer.js';
+import { OpraServiceLoader } from './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: OPRA_MODULE_OPTIONS,
+                    useValue: options,
+                },
+                {
+                    provide: OPRA_INITIALIZER,
+                    useClass: OpraServiceLoader
+                },
+                this.createI18nProvider()
+            ],
+            exports: [...(options.exports || [])]
+        };
+    }
+    static forRootAsync(asyncOptions) {
+        return {
+            module: OpraCoreModule_1,
+            imports: [...(asyncOptions.imports || [])],
+            providers: [
+                ...(asyncOptions.providers || []),
+                {
+                    provide: OPRA_MODULE_ID,
+                    useValue: crypto.randomUUID()
+                },
+                {
+                    provide: OPRA_INITIALIZER,
+                    useClass: OpraServiceLoader
+                },
+                ...this.createAsyncProviders(asyncOptions),
+                this.createI18nProvider(),
+            ]
+        };
+    }
+    static createI18nProvider() {
+        return {
+            provide: I18n,
+            inject: [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.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: OPRA_MODULE_OPTIONS,
+                useFactory: asyncOptions.useFactory,
+                inject: asyncOptions.inject || []
+            };
+        }
+        const useClass = asyncOptions.useClass || asyncOptions.useExisting;
+        if (useClass) {
+            return {
+                provide: 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 = __decorate([
+    Module({
+        providers: [
+            ServiceFactory,
+            MetadataScanner,
+            NestExplorer
+        ]
+    }),
+    __param(2, Inject(OPRA_MODULE_OPTIONS)),
+    __param(3, Inject(OPRA_INITIALIZER)),
+    __metadata("design:paramtypes", [HttpAdapterHost,
+        ModulesContainer, Object, OpraServiceLoader])
+], OpraCoreModule);
+export { OpraCoreModule };

package/esm/opra.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+import { OpraModuleAsyncOptions, OpraModuleOptions } from './interfaces/opra-module-options.interface.js';
+export declare class OpraModule {
+    static forRoot(options: OpraModuleOptions & Pick<DynamicModule, 'imports' | 'providers' | 'exports'>): DynamicModule;
+    static forRootAsync(asyncOptions: OpraModuleAsyncOptions): DynamicModule;
+}

package/esm/opra.module.js

@@ -0,0 +1,22 @@
+var OpraModule_1;
+import { __decorate } from "tslib";
+import { Module } from '@nestjs/common';
+import { OpraCoreModule } from './opra-core.module.js';
+let OpraModule = OpraModule_1 = class OpraModule {
+    static forRoot(options) {
+        return {
+            module: OpraModule_1,
+            imports: [OpraCoreModule.forRoot(options)]
+        };
+    }
+    static forRootAsync(asyncOptions) {
+        return {
+            module: OpraModule_1,
+            imports: [OpraCoreModule.forRootAsync(asyncOptions)]
+        };
+    }
+};
+OpraModule = OpraModule_1 = __decorate([
+    Module({})
+], OpraModule);
+export { OpraModule };

package/esm/services/nest-explorer.d.ts

@@ -0,0 +1,6 @@
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { Module } from '@nestjs/core/injector/module';
+export declare class NestExplorer {
+    exploreProviders(rootModule: Module, predicate: (wrapper: InstanceWrapper) => boolean): InstanceWrapper<any>[];
+    exploreResourceWrappers(rootModule: Module): InstanceWrapper[];
+}

package/esm/services/nest-explorer.js

@@ -0,0 +1,31 @@
+import { RESOURCE_METADATA } from '@opra/core';
+export 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(RESOURCE_METADATA, wrapper.instance.constructor));
+        });
+    }
+}

package/esm/services/service-loader.d.ts

@@ -0,0 +1,18 @@
+import { ApplicationConfig, HttpAdapterHost } from '@nestjs/core';
+import { Module } from '@nestjs/core/injector/module.js';
+import { OpraExpressAdapter, OpraService } from '@opra/core';
+import { I18n } from '@opra/i18n';
+import { ServiceFactory } from '../factories/service.factory.js';
+import { OpraModuleOptions } from '../interfaces/opra-module-options.interface.js';
+export declare class OpraServiceLoader {
+    private readonly logger;
+    private adapter;
+    protected readonly httpAdapterHost: HttpAdapterHost;
+    protected readonly applicationConfig: ApplicationConfig;
+    protected readonly opraFactory: ServiceFactory;
+    protected readonly opraModuleOptions: OpraModuleOptions;
+    protected readonly i18n: I18n;
+    initialize(rootModule: Module): Promise<void>;
+    stop(): Promise<void>;
+    protected registerExpress(service: OpraService, moduleOptions: OpraModuleOptions): Promise<OpraExpressAdapter | undefined>;
+}