@opra/nestjs 0.33.13 → 1.0.0-alpha.10

package/README.md

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

package/cjs/augmentation/http-controller.augmentation.js

@@ -0,0 +1,16 @@
+"use strict";
+// import { Controller } from '@nestjs/common';
+// import { DECORATOR, HttpController } from '@opra/common';
+//
+// /*
+//   Overrides HttpController decorator function to call NestJS's Controller() when decorator called
+//  */
+// const oldHttpControllerDecorator = HttpController[DECORATOR];
+// HttpController[DECORATOR] = function HttpControllerDecorator(options?: HttpController.Options) {
+//   const opraControllerDecorator = oldHttpControllerDecorator(options);
+//   const nestControllerDecorator = Controller({});
+//   return (target: Function) => {
+//     opraControllerDecorator(target);
+//     nestControllerDecorator(target);
+//   };
+// };

package/cjs/constants.js

@@ -1,9 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PARAM_ARGS_METADATA = exports.kAdapter = exports.kOptions = 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.kOptions = Symbol('kOptions');
-exports.kAdapter = Symbol('kAdapter');
-exports.PARAM_ARGS_METADATA = '__routeArguments__';
+exports.IS_PUBLIC_KEY = void 0;
+exports.IS_PUBLIC_KEY = 'isPublic';

package/cjs/decorators/public.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Public = void 0;
+const common_1 = require("@nestjs/common");
+const constants_js_1 = require("../constants.js");
+const Public = () => (0, common_1.SetMetadata)(constants_js_1.IS_PUBLIC_KEY, true);
+exports.Public = Public;

package/cjs/index.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 require("reflect-metadata");
-require("./augmentation/common-decorator.augmentation.js");
 require("./augmentation/nestjs.augmentation.js");
-tslib_1.__exportStar(require("./opra.module.js"), exports);
-tslib_1.__exportStar(require("./decorators/context.decorator.js"), exports);
-tslib_1.__exportStar(require("./interfaces/opra-module-options.interface.js"), exports);
-tslib_1.__exportStar(require("./opra-module-ref.js"), exports);
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./decorators/public.decorator.js"), exports);
+tslib_1.__exportStar(require("./opra-http.module.js"), exports);
+tslib_1.__exportStar(require("./opra-nestjs-adapter.js"), exports);

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

@@ -1,2 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+// import { ApiDocumentFactory } from '@opra/common';
+// import { ExpressAdapter, HttpAdapter } from '@opra/core';
+// export interface OpraModuleOptions extends HttpAdapter.Options {
+//   id?: any;
+//   document?: Partial<ApiDocumentFactory.InitArguments>;
+//
+//   /**
+//    * @default true
+//    */
+//   useGlobalPrefix?: boolean;
+// }
+// export interface ExpressModuleOptions extends OpraModuleOptions, HttpAdapter.Options {}
+// type OpraModuleOptionsWithoutId = Omit<OpraModuleOptions, 'id'>;
+// export interface OpraModuleOptionsFactory {
+//   createOptions(): Promise<OpraModuleOptionsWithoutId> | OpraModuleOptionsWithoutId;
+// }

package/cjs/opra-http-core.module.js

@@ -0,0 +1,60 @@
+"use strict";
+var OpraHttpCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpCoreModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const common_2 = require("@opra/common");
+const ts_gems_1 = require("ts-gems");
+const opra_nestjs_adapter_js_1 = require("./opra-nestjs-adapter.js");
+const opra_middleware_js_1 = require("./services/opra-middleware.js");
+let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
+    constructor(opraAdapter) {
+        this.opraAdapter = opraAdapter;
+    }
+    configure(consumer) {
+        consumer.apply(opra_middleware_js_1.OpraMiddleware).forRoutes({
+            path: '*',
+            method: common_1.RequestMethod.ALL,
+        });
+    }
+    static forRoot(init, options) {
+        const opraAdapter = new opra_nestjs_adapter_js_1.OpraNestAdapter(init, options);
+        const token = init?.id || opra_nestjs_adapter_js_1.OpraNestAdapter;
+        const providers = [
+            ...(init?.providers || []),
+            {
+                provide: opra_nestjs_adapter_js_1.OpraNestAdapter,
+                useFactory: async () => {
+                    (0, ts_gems_1.asMutable)(opraAdapter).document = await common_2.ApiDocumentFactory.createDocument({
+                        ...init,
+                        api: { protocol: 'http', name: init.name, controllers: init.controllers },
+                    });
+                    return opraAdapter;
+                },
+            },
+        ];
+        if (token !== opra_nestjs_adapter_js_1.OpraNestAdapter) {
+            providers.push({
+                provide: token,
+                useValue: opraAdapter,
+            });
+        }
+        return {
+            module: OpraHttpCoreModule_1,
+            controllers: opraAdapter.nestControllers,
+            imports: [...(init?.imports || [])],
+            exports: [...(init?.exports || []), token],
+            providers,
+        };
+    }
+    async onModuleDestroy() {
+        await this.opraAdapter.close();
+    }
+};
+exports.OpraHttpCoreModule = OpraHttpCoreModule;
+exports.OpraHttpCoreModule = OpraHttpCoreModule = OpraHttpCoreModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({}),
+    (0, common_1.Global)(),
+    tslib_1.__metadata("design:paramtypes", [opra_nestjs_adapter_js_1.OpraNestAdapter])
+], OpraHttpCoreModule);

package/cjs/opra-http.module.js

@@ -0,0 +1,24 @@
+"use strict";
+var OpraHttpModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const opra_http_core_module_js_1 = require("./opra-http-core.module.js");
+let OpraHttpModule = OpraHttpModule_1 = class OpraHttpModule {
+    /**
+     *
+     * @param init
+     * @param options
+     */
+    static forRoot(init, options) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [opra_http_core_module_js_1.OpraHttpCoreModule.forRoot(init, options)],
+        };
+    }
+};
+exports.OpraHttpModule = OpraHttpModule;
+exports.OpraHttpModule = OpraHttpModule = OpraHttpModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], OpraHttpModule);

package/cjs/opra-nestjs-adapter.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraNestAdapter = exports.kHandler = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const common_2 = require("@opra/common");
+const core_1 = require("@opra/core");
+const path_1 = tslib_1.__importDefault(require("path"));
+const ts_gems_1 = require("ts-gems");
+const public_decorator_1 = require("./decorators/public.decorator");
+const opra_exception_filter_js_1 = require("./services/opra-exception-filter.js");
+exports.kHandler = Symbol.for('kHandler');
+class OpraNestAdapter extends core_1.HttpAdapter {
+    constructor(init, options) {
+        super((function () {
+            const document = new common_2.ApiDocument();
+            document.api = new common_2.HttpApi(document);
+            return document;
+        })(), options);
+        this.nestControllers = [];
+        this.options = options;
+        let basePath = options?.basePath || '/';
+        if (!basePath.startsWith('/'))
+            basePath = '/' + basePath;
+        this._addRootController(basePath);
+        if (init.controllers)
+            init.controllers.forEach(c => this._addToNestControllers(c, basePath));
+    }
+    async close() {
+        //
+    }
+    _addRootController(basePath) {
+        const _this = this;
+        let RootController = class RootController {
+            schema(_req, next) {
+                _this[exports.kHandler].sendDocumentSchema(_req.opraContext).catch(next);
+            }
+        };
+        tslib_1.__decorate([
+            (0, common_1.Get)('/\\$schema'),
+            tslib_1.__param(0, (0, common_1.Req)()),
+            tslib_1.__param(1, (0, common_1.Next)()),
+            tslib_1.__metadata("design:type", Function),
+            tslib_1.__metadata("design:paramtypes", [Object, Function]),
+            tslib_1.__metadata("design:returntype", void 0)
+        ], RootController.prototype, "schema", null);
+        RootController = tslib_1.__decorate([
+            (0, common_1.Controller)({
+                path: basePath,
+            })
+        ], RootController);
+        if (this.options?.schemaRouteIsPublic) {
+            (0, public_decorator_1.Public)()(RootController.prototype, 'schema', Object.getOwnPropertyDescriptor(RootController.prototype, 'schema'));
+        }
+        this.nestControllers.push(RootController);
+    }
+    _addToNestControllers(sourceClass, currentPath) {
+        const metadata = Reflect.getMetadata(common_2.HTTP_CONTROLLER_METADATA, sourceClass);
+        if (!metadata)
+            return;
+        const newClass = {
+            [sourceClass.name]: class extends sourceClass {
+            },
+        }[sourceClass.name];
+        const newPath = metadata.path ? path_1.default.join(currentPath, metadata.path) : currentPath;
+        const adapter = this;
+        /** Inject exception filter */
+        (0, common_1.UseFilters)(new opra_exception_filter_js_1.OpraExceptionFilter(adapter))(newClass);
+        (0, common_1.Controller)()(newClass);
+        this.nestControllers.push(newClass);
+        if (metadata.operations) {
+            for (const [k, v] of Object.entries(metadata.operations)) {
+                const operationHandler = sourceClass.prototype[k];
+                Object.defineProperty(newClass.prototype, k, {
+                    writable: true,
+                    /** NestJS handler method */
+                    async value(_req) {
+                        const api = adapter.document.api;
+                        const controller = api.findController(sourceClass);
+                        const operation = controller?.operations.get(k);
+                        const context = (0, ts_gems_1.asMutable)(_req.opraContext);
+                        if (!(context && operation && typeof operationHandler === 'function')) {
+                            throw new common_2.NotFoundError({
+                                message: `No endpoint found for [${_req.method}]${_req.baseUrl}`,
+                                details: {
+                                    path: _req.baseUrl,
+                                    method: _req.method,
+                                },
+                            });
+                        }
+                        /** Configure the HttpContext */
+                        context.adapter = adapter;
+                        context.document = adapter.document;
+                        context.operation = operation;
+                        context.controller = operation.owner;
+                        context.controllerInstance = this;
+                        context.operationHandler = operationHandler;
+                        /** Handle request */
+                        await adapter[exports.kHandler].handleRequest(context);
+                    },
+                });
+                /** Copy metadata keys from source function to new one */
+                const metadataKeys = Reflect.getOwnMetadataKeys(operationHandler);
+                const newFn = newClass.prototype[k];
+                for (const key of metadataKeys) {
+                    const m = Reflect.getMetadata(key, operationHandler);
+                    Reflect.defineMetadata(key, m, newFn);
+                }
+                (0, common_1.Req)()(newClass.prototype, k, 0);
+                (0, common_1.Res)()(newClass.prototype, k, 1);
+                const descriptor = Object.getOwnPropertyDescriptor(newClass.prototype, k);
+                const operationPath = newPath + (v.path || '');
+                switch (v.method || 'GET') {
+                    case 'DELETE':
+                        /** Call @Delete decorator over new property */
+                        (0, common_1.Delete)(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'GET':
+                        /** Call @Get decorator over new property */
+                        (0, common_1.Get)(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'HEAD':
+                        /** Call @Head decorator over new property */
+                        (0, common_1.Head)(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'OPTIONS':
+                        /** Call @Options decorator over new property */
+                        (0, common_1.Options)(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'PATCH':
+                        /** Call @Patch decorator over new property */
+                        (0, common_1.Patch)(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'POST':
+                        /** Call @Post decorator over new property */
+                        (0, common_1.Post)(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'PUT':
+                        /** Call @Put decorator over new property */
+                        (0, common_1.Put)(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'SEARCH':
+                        /** Call @Search decorator over new property */
+                        (0, common_1.Search)(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        if (metadata.controllers) {
+            for (const child of metadata.controllers) {
+                if (!(0, common_2.isConstructor)(child))
+                    throw new TypeError('Controllers should be injectable a class');
+                this._addToNestControllers(child, newPath);
+            }
+        }
+    }
+}
+exports.OpraNestAdapter = OpraNestAdapter;

package/cjs/services/opra-exception-filter.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpraExceptionFilter = void 0;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const common_2 = require("@opra/common");
-let OpraExceptionFilter = class OpraExceptionFilter {
-    catch(exception) {
-        if (exception instanceof common_2.OpraException)
-            return true;
-        throw exception;
+exports.OpraExceptionFilter = exports.kHandler = void 0;
+const core_1 = require("@opra/core");
+exports.kHandler = Symbol.for('kHandler');
+class OpraExceptionFilter {
+    constructor(adapter) {
+        this.adapter = adapter;
     }
-};
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const _res = ctx.getResponse();
+        const error = (0, core_1.wrapException)(exception);
+        const response = core_1.HttpOutgoing.from(_res);
+        return this.adapter[exports.kHandler].sendErrorResponse(response, [error]);
+    }
+}
 exports.OpraExceptionFilter = OpraExceptionFilter;
-exports.OpraExceptionFilter = OpraExceptionFilter = tslib_1.__decorate([
-    (0, common_1.Catch)(common_2.OpraException)
-], OpraExceptionFilter);

package/cjs/services/opra-middleware.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraMiddleware = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@opra/core");
+let OpraMiddleware = class OpraMiddleware {
+    use(req, res, next) {
+        const request = core_1.HttpIncoming.from(req);
+        const response = core_1.HttpOutgoing.from(res);
+        /** Create the HttpContext */
+        req.opraContext = new core_1.HttpContext({
+            adapter: {},
+            platform: req.route ? 'express' : 'fastify',
+            request,
+            response,
+        });
+        next();
+    }
+};
+exports.OpraMiddleware = OpraMiddleware;
+exports.OpraMiddleware = OpraMiddleware = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], OpraMiddleware);

package/esm/augmentation/http-controller.augmentation.js

@@ -0,0 +1,16 @@
+"use strict";
+// import { Controller } from '@nestjs/common';
+// import { DECORATOR, HttpController } from '@opra/common';
+//
+// /*
+//   Overrides HttpController decorator function to call NestJS's Controller() when decorator called
+//  */
+// const oldHttpControllerDecorator = HttpController[DECORATOR];
+// HttpController[DECORATOR] = function HttpControllerDecorator(options?: HttpController.Options) {
+//   const opraControllerDecorator = oldHttpControllerDecorator(options);
+//   const nestControllerDecorator = Controller({});
+//   return (target: Function) => {
+//     opraControllerDecorator(target);
+//     nestControllerDecorator(target);
+//   };
+// };

package/esm/constants.js

@@ -1,6 +1 @@
-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__';
+export const IS_PUBLIC_KEY = 'isPublic';

package/esm/decorators/public.decorator.js

@@ -0,0 +1,3 @@
+import { SetMetadata } from '@nestjs/common';
+import { IS_PUBLIC_KEY } from '../constants.js';
+export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

package/esm/index.js

@@ -1,7 +1,6 @@
 import 'reflect-metadata';
-import './augmentation/common-decorator.augmentation.js';
 import './augmentation/nestjs.augmentation.js';
-export * from './opra.module.js';
-export * from './decorators/context.decorator.js';
-export * from './interfaces/opra-module-options.interface.js';
-export * from './opra-module-ref.js';
+export * from './constants.js';
+export * from './decorators/public.decorator.js';
+export * from './opra-http.module.js';
+export * from './opra-nestjs-adapter.js';

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

@@ -1 +1,17 @@
-export {};
+"use strict";
+// import { ApiDocumentFactory } from '@opra/common';
+// import { ExpressAdapter, HttpAdapter } from '@opra/core';
+// export interface OpraModuleOptions extends HttpAdapter.Options {
+//   id?: any;
+//   document?: Partial<ApiDocumentFactory.InitArguments>;
+//
+//   /**
+//    * @default true
+//    */
+//   useGlobalPrefix?: boolean;
+// }
+// export interface ExpressModuleOptions extends OpraModuleOptions, HttpAdapter.Options {}
+// type OpraModuleOptionsWithoutId = Omit<OpraModuleOptions, 'id'>;
+// export interface OpraModuleOptionsFactory {
+//   createOptions(): Promise<OpraModuleOptionsWithoutId> | OpraModuleOptionsWithoutId;
+// }

package/esm/opra-http-core.module.js

@@ -0,0 +1,57 @@
+var OpraHttpCoreModule_1;
+import { __decorate, __metadata } from "tslib";
+import { Global, Module, RequestMethod, } from '@nestjs/common';
+import { ApiDocumentFactory } from '@opra/common';
+import { asMutable } from 'ts-gems';
+import { OpraNestAdapter } from './opra-nestjs-adapter.js';
+import { OpraMiddleware } from './services/opra-middleware.js';
+let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
+    constructor(opraAdapter) {
+        this.opraAdapter = opraAdapter;
+    }
+    configure(consumer) {
+        consumer.apply(OpraMiddleware).forRoutes({
+            path: '*',
+            method: RequestMethod.ALL,
+        });
+    }
+    static forRoot(init, options) {
+        const opraAdapter = new OpraNestAdapter(init, options);
+        const token = init?.id || OpraNestAdapter;
+        const providers = [
+            ...(init?.providers || []),
+            {
+                provide: OpraNestAdapter,
+                useFactory: async () => {
+                    asMutable(opraAdapter).document = await ApiDocumentFactory.createDocument({
+                        ...init,
+                        api: { protocol: 'http', name: init.name, controllers: init.controllers },
+                    });
+                    return opraAdapter;
+                },
+            },
+        ];
+        if (token !== OpraNestAdapter) {
+            providers.push({
+                provide: token,
+                useValue: opraAdapter,
+            });
+        }
+        return {
+            module: OpraHttpCoreModule_1,
+            controllers: opraAdapter.nestControllers,
+            imports: [...(init?.imports || [])],
+            exports: [...(init?.exports || []), token],
+            providers,
+        };
+    }
+    async onModuleDestroy() {
+        await this.opraAdapter.close();
+    }
+};
+OpraHttpCoreModule = OpraHttpCoreModule_1 = __decorate([
+    Module({}),
+    Global(),
+    __metadata("design:paramtypes", [OpraNestAdapter])
+], OpraHttpCoreModule);
+export { OpraHttpCoreModule };

package/esm/opra-http.module.js

@@ -0,0 +1,21 @@
+var OpraHttpModule_1;
+import { __decorate } from "tslib";
+import { Module } from '@nestjs/common';
+import { OpraHttpCoreModule } from './opra-http-core.module.js';
+let OpraHttpModule = OpraHttpModule_1 = class OpraHttpModule {
+    /**
+     *
+     * @param init
+     * @param options
+     */
+    static forRoot(init, options) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [OpraHttpCoreModule.forRoot(init, options)],
+        };
+    }
+};
+OpraHttpModule = OpraHttpModule_1 = __decorate([
+    Module({})
+], OpraHttpModule);
+export { OpraHttpModule };