@opra/nestjs 0.25.4 → 0.26.0

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

@@ -25,67 +25,75 @@ let OpraApiFactory = exports.OpraApiFactory = class OpraApiFactory {
         const info = { title: '', version: '', ...moduleOptions.info };
         info.title = info.title || 'Untitled service';
         info.version = info.version || '1';
-        const resources = [];
+        const root = {
+            resources: []
+        };
         const apiSchema = {
             version: common_2.OpraSchema.SpecVersion,
             info,
             types: [],
-            resources
+            root
         };
         /*
          * Walk through modules and add Resource instances to the api schema
          */
-        const wrappers = this.explorerService.exploreSourceWrappers(rootModule);
-        for (const wrapper of wrappers) {
+        this.explorerService.exploreResources(rootModule, (wrapper, modulePath) => {
             const instance = wrapper.instance;
             const ctor = instance.constructor;
             const metadata = Reflect.getMetadata(common_2.RESOURCE_METADATA, ctor);
-            if (common_2.OpraSchema.isSource(metadata))
-                resources.push(instance);
-        }
-        for (const wrapper of wrappers) {
-            const instance = wrapper.instance;
-            const ctor = instance.constructor;
-            const sourceDef = Reflect.getMetadata(common_2.RESOURCE_METADATA, ctor);
-            /* istanbul ignore next */
-            if (!sourceDef)
-                continue;
-            resources.push(instance);
-            /* Wrap resolver functions */
-            const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            if (sourceDef.operations &&
-                (common_2.OpraSchema.isCollection(sourceDef) || common_2.OpraSchema.isSingleton(sourceDef) || common_2.OpraSchema.isStorage(sourceDef))) {
-                for (const methodName of Object.keys(sourceDef.operations)) {
-                    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(constants_js_1.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(constants_js_1.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);
+            let node = root;
+            modulePath.forEach(m => {
+                const mt = Reflect.getMetadata(common_2.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(constants_js_1.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(constants_js_1.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 common_2.DocumentFactory.createDocument(apiSchema);
+        return common_2.ApiDocumentFactory.createDocument(apiSchema);
     }
     _createHandler(callback) {
         return function (ctx) {

package/cjs/services/nest-explorer.js

@@ -3,32 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestExplorer = void 0;
 const common_1 = require("@opra/common");
 class NestExplorer {
-    exploreProviders(rootModule, predicate) {
+    exploreProviders(rootModule, callback) {
         const modules = new Set();
-        const wrappers = 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()) {
-                if (!wrappers.has(wrapper) && predicate(wrapper))
-                    wrappers.add(wrapper);
+                callback(wrapper, tree);
                 if (wrapper.host)
                     scanModules(wrapper.host);
             }
+            tree.pop();
         };
         scanModules(rootModule);
-        return Array.from(wrappers.values());
     }
-    exploreSourceWrappers(rootModule) {
-        return this.exploreProviders(rootModule, (wrapper) => {
-            return !!(wrapper.instance
+    exploreResources(rootModule, callback) {
+        this.exploreProviders(rootModule, (wrapper, tree) => {
+            if (wrapper.instance
                 && typeof wrapper.instance === 'object'
                 && wrapper.instance.constructor
-                && common_1.OpraSchema.isSource(Reflect.getMetadata(common_1.RESOURCE_METADATA, wrapper.instance.constructor)));
+                && common_1.OpraSchema.isResource(Reflect.getMetadata(common_1.RESOURCE_METADATA, wrapper.instance.constructor))) {
+                callback(wrapper, tree);
+            }
+            return false;
         });
     }
 }

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

@@ -30,7 +30,7 @@ class OpraApiLoader {
         };
         try {
             const apiDocument = await this.opraFactory.generateService(rootModule, options, 'http');
-            if (!apiDocument.resources.size) {
+            if (!Object.keys(apiDocument.root).length) {
                 this.logger.warn(`No Sources found (${name})`);
                 return;
             }

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

@@ -6,7 +6,7 @@ import { ExternalContextCreator } from '@nestjs/core/helpers/external-context-cr
 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 { DocumentFactory, OpraSchema, RESOURCE_METADATA } from '@opra/common';
+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';
@@ -22,67 +22,75 @@ export let OpraApiFactory = class OpraApiFactory {
         const info = { title: '', version: '', ...moduleOptions.info };
         info.title = info.title || 'Untitled service';
         info.version = info.version || '1';
-        const resources = [];
+        const root = {
+            resources: []
+        };
         const apiSchema = {
             version: OpraSchema.SpecVersion,
             info,
             types: [],
-            resources
+            root
         };
         /*
          * Walk through modules and add Resource instances to the api schema
          */
-        const wrappers = this.explorerService.exploreSourceWrappers(rootModule);
-        for (const wrapper of wrappers) {
+        this.explorerService.exploreResources(rootModule, (wrapper, modulePath) => {
             const instance = wrapper.instance;
             const ctor = instance.constructor;
             const metadata = Reflect.getMetadata(RESOURCE_METADATA, ctor);
-            if (OpraSchema.isSource(metadata))
-                resources.push(instance);
-        }
-        for (const wrapper of wrappers) {
-            const instance = wrapper.instance;
-            const ctor = instance.constructor;
-            const sourceDef = Reflect.getMetadata(RESOURCE_METADATA, ctor);
-            /* istanbul ignore next */
-            if (!sourceDef)
-                continue;
-            resources.push(instance);
-            /* Wrap resolver functions */
-            const isRequestScoped = !wrapper.isDependencyTreeStatic();
-            if (sourceDef.operations &&
-                (OpraSchema.isCollection(sourceDef) || OpraSchema.isSingleton(sourceDef) || OpraSchema.isStorage(sourceDef))) {
-                for (const methodName of Object.keys(sourceDef.operations)) {
-                    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);
+            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 DocumentFactory.createDocument(apiSchema);
+        return ApiDocumentFactory.createDocument(apiSchema);
     }
     _createHandler(callback) {
         return function (ctx) {

package/esm/services/nest-explorer.js

@@ -1,31 +1,34 @@
 import { OpraSchema, RESOURCE_METADATA } from '@opra/common';
 export class NestExplorer {
-    exploreProviders(rootModule, predicate) {
+    exploreProviders(rootModule, callback) {
         const modules = new Set();
-        const wrappers = 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()) {
-                if (!wrappers.has(wrapper) && predicate(wrapper))
-                    wrappers.add(wrapper);
+                callback(wrapper, tree);
                 if (wrapper.host)
                     scanModules(wrapper.host);
             }
+            tree.pop();
         };
         scanModules(rootModule);
-        return Array.from(wrappers.values());
     }
-    exploreSourceWrappers(rootModule) {
-        return this.exploreProviders(rootModule, (wrapper) => {
-            return !!(wrapper.instance
+    exploreResources(rootModule, callback) {
+        this.exploreProviders(rootModule, (wrapper, tree) => {
+            if (wrapper.instance
                 && typeof wrapper.instance === 'object'
                 && wrapper.instance.constructor
-                && OpraSchema.isSource(Reflect.getMetadata(RESOURCE_METADATA, wrapper.instance.constructor)));
+                && OpraSchema.isResource(Reflect.getMetadata(RESOURCE_METADATA, wrapper.instance.constructor))) {
+                callback(wrapper, tree);
+            }
+            return false;
         });
     }
 }

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

@@ -27,7 +27,7 @@ export class OpraApiLoader {
         };
         try {
             const apiDocument = await this.opraFactory.generateService(rootModule, options, 'http');
-            if (!apiDocument.resources.size) {
+            if (!Object.keys(apiDocument.root).length) {
                 this.logger.warn(`No Sources found (${name})`);
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/nestjs",
-  "version": "0.25.4",
+  "version": "0.26.0",
   "description": "Opra NestJS module",
   "author": "Panates",
   "license": "MIT",
@@ -25,8 +25,8 @@
     "clean:cover": "rimraf ../../coverage/nestjs"
   },
   "dependencies": {
-    "@opra/common": "^0.25.4",
-    "@opra/core": "^0.25.4",
+    "@opra/common": "^0.26.0",
+    "@opra/core": "^0.26.0",
     "fast-tokenizer": "^1.2.2",
     "lodash.head": "^4.0.1",
     "lodash.identity": "^3.0.0",
@@ -40,7 +40,7 @@
     "@nestjs/testing": "^10.2.4",
     "@types/lodash": "^4.14.197",
     "filedirname": "^2.7.0",
-    "ts-gems": "^2.4.1"
+    "ts-gems": "^2.5.0"
   },
   "type": "module",
   "module": "./esm/index.js",

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 { HttpAdapter } from '@opra/core';
-export type OpraModuleOptions = HttpAdapter.Options & {
+import { NodeHttpAdapter } from '@opra/core';
+export type OpraModuleOptions = NodeHttpAdapter.Options & {
     id?: any;
     info?: OpraSchema.DocumentInfo;
     /**

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

@@ -1,6 +1,8 @@
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
 import { Module } from '@nestjs/core/injector/module';
+type WrapperCallback = (wrapper: InstanceWrapper, tree: Module[]) => void;
 export declare class NestExplorer {
-    exploreProviders(rootModule: Module, predicate: (wrapper: InstanceWrapper) => boolean): InstanceWrapper<any>[];
-    exploreSourceWrappers(rootModule: Module): InstanceWrapper[];
+    exploreProviders(rootModule: Module, callback: WrapperCallback): void;
+    exploreResources(rootModule: Module, callback: WrapperCallback): void;
 }
+export {};