@opra/nestjs 0.33.13 → 1.0.0-alpha.2

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

@@ -1,85 +0,0 @@
-"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");
-const opra_module_ref_js_1 = require("../opra-module-ref.js");
-class OpraApiLoader {
-    constructor() {
-        this.logger = new common_1.Logger(OpraApiLoader.name, { timestamp: true });
-        this.opraModuleRef = new opra_module_ref_js_1.OpraModuleRef();
-    }
-    async initialize(rootModule) {
-        const httpAdapter = this.httpAdapterHost?.httpAdapter;
-        const globalPrefix = this.applicationConfig.getGlobalPrefix();
-        const platformName = httpAdapter.getType();
-        const moduleOptions = this.options;
-        this.opraModuleRef[constants_js_1.kOptions] = this.options;
-        let prefixPath = new common_2.OpraURLPath((moduleOptions.useGlobalPrefix !== false ? globalPrefix : ''));
-        if (moduleOptions.basePath)
-            prefixPath = prefixPath.join(moduleOptions.basePath);
-        const name = moduleOptions.document?.info?.title || 'untitled service';
-        const options = {
-            ...moduleOptions,
-            basePath: prefixPath.toString()
-        };
-        try {
-            const apiDocument = await this.opraFactory.generateService(rootModule, 'http', options.document);
-            if (!Object.keys(apiDocument.root).length) {
-                this.logger.warn(`No Sources found (${name})`);
-                return;
-            }
-            if (platformName === 'express') {
-                this.opraModuleRef[constants_js_1.kAdapter] = await this.registerExpress(apiDocument, options);
-                // else if (platformName === 'fastify')
-                // await this.registerFastify();
-            }
-            else { // noinspection ExceptionCaughtLocallyJS
-                throw new Error(`No support for current HttpAdapter: ${platformName}`);
-            }
-            this.logger.log(`Mapped {${prefixPath.toString() || '/'}} to "${name}" service`);
-        }
-        catch (e) {
-            this.logger.error(e);
-            throw e;
-        }
-    }
-    async stop() {
-        //
-    }
-    async registerExpress(apiDocument, moduleOptions) {
-        const httpAdapter = this.httpAdapterHost.httpAdapter;
-        /* istanbul ignore next */
-        if (!httpAdapter)
-            throw new Error('HttpAdapterHost is not initialized');
-        const app = httpAdapter.getInstance();
-        const logger = moduleOptions.logger ||
-            (process.env.NODE_ENV === 'test' ? undefined : new common_1.Logger(apiDocument.info.title));
-        return await core_2.ExpressAdapter.create(app, apiDocument, {
-            ...moduleOptions,
-            logger,
-        });
-    }
-}
-exports.OpraApiLoader = OpraApiLoader;
-tslib_1.__decorate([
-    (0, common_1.Inject)(),
-    tslib_1.__metadata("design:type", core_1.HttpAdapterHost)
-], OpraApiLoader.prototype, "httpAdapterHost", void 0);
-tslib_1.__decorate([
-    (0, common_1.Inject)(),
-    tslib_1.__metadata("design:type", core_1.ApplicationConfig)
-], OpraApiLoader.prototype, "applicationConfig", void 0);
-tslib_1.__decorate([
-    (0, common_1.Inject)(),
-    tslib_1.__metadata("design:type", opra_api_factory_js_1.OpraApiFactory)
-], OpraApiLoader.prototype, "opraFactory", void 0);
-tslib_1.__decorate([
-    (0, common_1.Inject)(constants_js_1.OPRA_MODULE_OPTIONS),
-    tslib_1.__metadata("design:type", Object)
-], OpraApiLoader.prototype, "options", void 0);

package/cjs/types.js

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

package/cjs/utils/class.utils.js

@@ -1,25 +0,0 @@
-"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

@@ -1,37 +0,0 @@
-"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 = (0, fast_tokenizer_1.tokenize)(functionAsString, {
-        // keepBrackets: true,
-        keepDelimiters: true,
-        keepQuotes: true,
-        brackets: {}
-    });
-    let k = 0;
-    let s = '';
-    for (const token of tokenizer) {
-        if (token.startsWith('(')) {
-            s += token.substring(1);
-            k++;
-        }
-        else if (token.startsWith(')')) {
-            if (k === 1)
-                break;
-        }
-        else if (k)
-            s += token;
-    }
-    const x = (0, fast_tokenizer_1.splitString)(s, {
-        brackets: {
-            '{': '}',
-            '(': ')',
-            '[': ']',
-            '/*': '*/'
-        }, delimiters: ','
-    });
-    return x.length > 1 ? x.length : (x[0] ? 1 : 0);
-}
-exports.getNumberOfArguments = getNumberOfArguments;

package/cjs/utils/param.utils.js

@@ -1,24 +0,0 @@
-"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) => {
-        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/esm/augmentation/common-decorator.augmentation.js

@@ -1,38 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { Collection, DECORATOR, Singleton, Storage } from '@opra/common';
-/*
-  Overrides Collection decorator function to call NestJS's Injectable() when Collection decorator called
- */
-const oldCollectionDecorator = Collection[DECORATOR];
-Collection[DECORATOR] = function CollectionDecorator(...args) {
-    const collectionDecorator = oldCollectionDecorator(...args);
-    const injectableDecorator = Injectable();
-    return (target) => {
-        collectionDecorator(target);
-        injectableDecorator(target);
-    };
-};
-/*
-  Overrides Singleton decorator function to call NestJS's Injectable() when Singleton decorator called
- */
-const oldSingletonDecorator = Singleton[DECORATOR];
-Singleton[DECORATOR] = function SingletonDecorator(...args) {
-    const singletonDecorator = oldSingletonDecorator(...args);
-    const injectableDecorator = Injectable();
-    return (target) => {
-        singletonDecorator(target);
-        injectableDecorator(target);
-    };
-};
-/*
-  Overrides Singleton decorator function to call NestJS's Injectable() when Singleton decorator called
- */
-const oldStorageDecorator = Storage[DECORATOR];
-Storage[DECORATOR] = function StorageDecorator(...args) {
-    const storageDecorator = oldStorageDecorator(...args);
-    const injectableDecorator = Injectable();
-    return (target) => {
-        storageDecorator(target);
-        injectableDecorator(target);
-    };
-};

package/esm/constants.js

@@ -1,6 +0,0 @@
-export const OPRA_MODULE_OPTIONS = 'opra:module_options';
-export const OPRA_MODULE_ID = 'opra:module_id';
-export const OPRA_INITIALIZER = 'opra_initializer';
-export const kOptions = Symbol('kOptions');
-export const kAdapter = Symbol('kAdapter');
-export const PARAM_ARGS_METADATA = '__routeArguments__';

package/esm/decorators/context.decorator.js

@@ -1,7 +0,0 @@
-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 `RequestContext`.
- */
-export const Context = createOpraParamDecorator(HandlerParamType.CONTEXT);

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

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

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

@@ -1,197 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import head from 'lodash.head';
-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 { ApiDocumentFactory, 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';
-const noOpFunction = () => void 0;
-let OpraApiFactory = class OpraApiFactory {
-    constructor() {
-        this.paramsFactory = new OpraParamsFactory();
-        this.injector = new Injector();
-    }
-    async generateService(rootModule, contextType, apiSchema) {
-        const info = { ...apiSchema?.info };
-        info.title = info.title || 'Untitled service';
-        info.version = info.version || '1';
-        const root = {
-            resources: []
-        };
-        const apiInit = {
-            version: OpraSchema.SpecVersion,
-            ...apiSchema,
-            info,
-            types: apiSchema?.types || [],
-            root
-        };
-        /*
-         * Walk through modules and add Resource instances to the api schema
-         */
-        this.explorerService.exploreResources(rootModule, (wrapper, modulePath) => {
-            const instance = wrapper.instance;
-            const ctor = instance.constructor;
-            const metadata = Reflect.getMetadata(RESOURCE_METADATA, ctor);
-            let node = root;
-            modulePath.forEach(m => {
-                const mt = Reflect.getMetadata(RESOURCE_METADATA, m._metatype);
-                if (mt) {
-                    let n = node.resources.find(x => x.controller === m.instance);
-                    if (!n) {
-                        n = {
-                            ...mt,
-                            kind: 'Container',
-                            resources: [...(mt.resources || [])],
-                            controller: m.instance
-                        };
-                        node.resources.push(n);
-                    }
-                    node = n;
-                }
-            });
-            // Do not add Modules decorated with @Container
-            if (wrapper.metatype !== wrapper.host?.metatype)
-                node.resources.push(instance);
-            /* Wrap operation and action functions */
-            const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            const methodNames = [...Object.keys(metadata.operations || []), ...Object.keys(metadata.actions || [])];
-            for (const methodName of methodNames) {
-                const endpointFunction = instance[methodName];
-                const nestHandlerName = methodName + '_nestjs';
-                // Skip patch if controller do not have function for endpoint or already patched before
-                if (typeof endpointFunction !== '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 paramArgsMetadata = Reflect.getMetadata(PARAM_ARGS_METADATA, instance.constructor, methodName);
-                const hasParamsArgs = !!paramArgsMetadata;
-                const patchedFn = instance[nestHandlerName] = function (...args) {
-                    if (hasParamsArgs)
-                        return endpointFunction.apply(this, args);
-                    return endpointFunction.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(endpointFunction).forEach(k => {
-                    const m = Reflect.getMetadata(k, endpointFunction);
-                    Reflect.defineMetadata(k, m, patchedFn);
-                });
-                this._createContextCallback(instance, wrapper, rootModule, methodName, isRequestScoped, contextType);
-            }
-        });
-        // Create api document
-        return ApiDocumentFactory.createDocument(apiInit);
-    }
-    _createHandler(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;
-        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 contextCallback = this.externalContextCreator.create(contextInstance, contextInstance[methodName], nestHandlerName, PARAM_ARGS_METADATA, paramsFactory, contextId, wrapper.id, options, opraContext.protocol);
-                contextInstance[methodName] = this._createHandler(contextCallback);
-                return contextCallback(...args);
-            }
-            : this.externalContextCreator.create(instance, instance[nestHandlerName], nestHandlerName, PARAM_ARGS_METADATA, paramsFactory, undefined, undefined, options, contextType);
-        instance[methodName] = this._createHandler(callback);
-        return callback;
-    }
-    // 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)
-], OpraApiFactory.prototype, "modulesContainer", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", ExternalContextCreator)
-], OpraApiFactory.prototype, "externalContextCreator", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", NestExplorer)
-], OpraApiFactory.prototype, "explorerService", void 0);
-OpraApiFactory = __decorate([
-    Injectable()
-], OpraApiFactory);
-export { OpraApiFactory };

package/esm/factories/params.factory.js

@@ -1,19 +0,0 @@
-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.REQUEST:
-                return args[3].request;
-            case HandlerParamType.RESPONSE:
-                return args[3].response;
-            default:
-                return null;
-        }
-    }
-}

package/esm/opra-core.module.js

@@ -1,137 +0,0 @@
-var OpraCoreModule_1;
-import { __decorate, __metadata, __param } from "tslib";
-import * as crypto from 'crypto';
-import { Global, 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 { OpraModuleRef } from './opra-module-ref.js';
-import { NestExplorer } from './services/nest-explorer.js';
-import { OpraApiLoader } from './services/opra-api-loader.js';
-let OpraCoreModule = OpraCoreModule_1 = class OpraCoreModule {
-    constructor(httpAdapterHost, modulesContainer, options, apiLoader) {
-        this.httpAdapterHost = httpAdapterHost;
-        this.modulesContainer = modulesContainer;
-        this.options = options;
-        this.apiLoader = apiLoader;
-    }
-    static forRoot(options) {
-        const providers = [
-            ...(options.providers || []),
-            {
-                provide: OPRA_MODULE_OPTIONS,
-                useValue: options,
-            },
-            {
-                provide: OPRA_INITIALIZER,
-                useClass: OpraApiLoader
-            },
-            {
-                provide: options.id || OpraModuleRef,
-                inject: [OPRA_INITIALIZER],
-                useFactory: (apiLoader) => {
-                    return apiLoader.opraModuleRef;
-                }
-            }
-        ];
-        return {
-            module: OpraCoreModule_1,
-            imports: [...(options.imports || [])],
-            exports: [...(options.exports || [])],
-            providers
-        };
-    }
-    static forRootAsync(asyncOptions) {
-        return {
-            module: OpraCoreModule_1,
-            imports: [...(asyncOptions.imports || [])],
-            providers: [
-                ...(asyncOptions.providers || []),
-                {
-                    provide: OPRA_MODULE_ID,
-                    useValue: crypto.randomUUID()
-                },
-                {
-                    provide: OPRA_INITIALIZER,
-                    useClass: OpraApiLoader
-                },
-                {
-                    provide: asyncOptions.id || OpraModuleRef,
-                    inject: [OPRA_INITIALIZER],
-                    useFactory: (apiLoader) => {
-                        return apiLoader.opraModuleRef;
-                    }
-                },
-                ...this.createAsyncProviders(asyncOptions)
-            ]
-        };
-    }
-    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.apiLoader.initialize(opraModule);
-        }
-    }
-    async onModuleDestroy() {
-        await this.apiLoader.stop();
-    }
-};
-OpraCoreModule = OpraCoreModule_1 = __decorate([
-    Module({
-        providers: [
-            OpraApiFactory,
-            MetadataScanner,
-            NestExplorer
-        ]
-    }),
-    Global(),
-    __param(2, Inject(OPRA_MODULE_OPTIONS)),
-    __param(3, Inject(OPRA_INITIALIZER)),
-    __metadata("design:paramtypes", [HttpAdapterHost,
-        ModulesContainer, Object, OpraApiLoader])
-], OpraCoreModule);
-export { OpraCoreModule };

package/esm/opra-module-ref.js

@@ -1,12 +0,0 @@
-import { kAdapter, kOptions } from './constants.js';
-export class OpraModuleRef {
-    get adapter() {
-        return this[kAdapter];
-    }
-    get api() {
-        return this[kAdapter].api;
-    }
-    get options() {
-        return this[kOptions];
-    }
-}

package/esm/opra.module.js

@@ -1,22 +0,0 @@
-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.js

@@ -1,34 +0,0 @@
-import { OpraSchema, RESOURCE_METADATA } from '@opra/common';
-export class NestExplorer {
-    exploreProviders(rootModule, callback) {
-        const modules = new Set();
-        const tree = [];
-        const scanModules = (m) => {
-            if (modules.has(m))
-                return;
-            modules.add(m);
-            tree.push(m);
-            for (const mm of m.imports.values()) {
-                scanModules(mm);
-            }
-            for (const wrapper of m.providers.values()) {
-                callback(wrapper, tree);
-                if (wrapper.host)
-                    scanModules(wrapper.host);
-            }
-            tree.pop();
-        };
-        scanModules(rootModule);
-    }
-    exploreResources(rootModule, callback) {
-        this.exploreProviders(rootModule, (wrapper, tree) => {
-            if (wrapper.instance
-                && typeof wrapper.instance === 'object'
-                && wrapper.instance.constructor
-                && OpraSchema.isResource(Reflect.getMetadata(RESOURCE_METADATA, wrapper.instance.constructor))) {
-                callback(wrapper, tree);
-            }
-            return false;
-        });
-    }
-}