@opra/nestjs-http 1.11.0

package/LICENSE

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

package/README.md

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

package/cjs/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPRA_HTTP_API_CONFIG = void 0;
+exports.OPRA_HTTP_API_CONFIG = 'OPRA_HTTP_API_CONFIG';

package/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Public = exports.OpraNestUtils = exports.IS_PUBLIC_KEY = void 0;
+const tslib_1 = require("tslib");
+const nestjs_1 = require("@opra/nestjs");
+Object.defineProperty(exports, "IS_PUBLIC_KEY", { enumerable: true, get: function () { return nestjs_1.IS_PUBLIC_KEY; } });
+Object.defineProperty(exports, "OpraNestUtils", { enumerable: true, get: function () { return nestjs_1.OpraNestUtils; } });
+Object.defineProperty(exports, "Public", { enumerable: true, get: function () { return nestjs_1.Public; } });
+tslib_1.__exportStar(require("./constants.js"), exports);
+tslib_1.__exportStar(require("./opra-exception-filter.js"), exports);
+tslib_1.__exportStar(require("./opra-http.module.js"), exports);
+tslib_1.__exportStar(require("./opra-http-nestjs-adapter.js"), exports);
+tslib_1.__exportStar(require("./opra-middleware.js"), exports);

package/cjs/opra-exception-filter.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraExceptionFilter = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const opra_http_nestjs_adapter_js_1 = require("./opra-http-nestjs-adapter.js");
+let OpraExceptionFilter = class OpraExceptionFilter extends core_1.BaseExceptionFilter {
+    constructor(moduleRef) {
+        super();
+        this.moduleRef = moduleRef;
+    }
+    catch(exception, host) {
+        const ctx = host.switchToHttp().getRequest().opraContext;
+        if (ctx) {
+            const adapter = this.moduleRef.get(opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter);
+            ctx.errors.push(exception);
+            return adapter.handler.sendResponse(ctx);
+        }
+        super.catch(exception, host);
+    }
+};
+exports.OpraExceptionFilter = OpraExceptionFilter;
+exports.OpraExceptionFilter = OpraExceptionFilter = tslib_1.__decorate([
+    (0, common_1.Catch)(),
+    tslib_1.__metadata("design:paramtypes", [core_1.ModuleRef])
+], OpraExceptionFilter);

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

@@ -0,0 +1,119 @@
+"use strict";
+var OpraHttpCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpCoreModule = void 0;
+const tslib_1 = require("tslib");
+const objects_1 = require("@jsopen/objects");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const common_2 = require("@opra/common");
+const constants_js_1 = require("./constants.js");
+const opra_exception_filter_js_1 = require("./opra-exception-filter.js");
+const opra_http_nestjs_adapter_js_1 = require("./opra-http-nestjs-adapter.js");
+const opra_middleware_js_1 = require("./opra-middleware.js");
+const opraHttpNestjsAdapterToken = Symbol('OpraHttpNestjsAdapter');
+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(moduleOptions) {
+        return this._getDynamicModule({
+            ...moduleOptions,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                {
+                    provide: constants_js_1.OPRA_HTTP_API_CONFIG,
+                    useValue: { ...moduleOptions },
+                },
+            ],
+        });
+    }
+    static forRootAsync(moduleOptions) {
+        if (!moduleOptions.useFactory)
+            throw new Error('Invalid configuration. Must provide "useFactory"');
+        return this._getDynamicModule({
+            ...moduleOptions,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                {
+                    provide: constants_js_1.OPRA_HTTP_API_CONFIG,
+                    inject: moduleOptions.inject,
+                    useFactory: moduleOptions.useFactory,
+                },
+            ],
+        });
+    }
+    static _getDynamicModule(moduleOptions) {
+        const token = moduleOptions?.token || opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter;
+        const opraNestAdapter = new opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter({
+            ...moduleOptions,
+            interceptors: undefined,
+        });
+        const adapterProvider = {
+            provide: token,
+            inject: [core_1.ModuleRef, constants_js_1.OPRA_HTTP_API_CONFIG],
+            useFactory: async (moduleRef, apiConfig) => {
+                opraNestAdapter.scope = apiConfig.scope;
+                opraNestAdapter.logger =
+                    opraNestAdapter.logger || new common_1.Logger(apiConfig.name);
+                opraNestAdapter._document =
+                    await common_2.ApiDocumentFactory.createDocument({
+                        ...apiConfig,
+                        api: {
+                            transport: 'http',
+                            name: apiConfig.name,
+                            description: apiConfig.description,
+                            controllers: moduleOptions.controllers,
+                        },
+                    });
+                if (moduleOptions.interceptors) {
+                    opraNestAdapter.interceptors = moduleOptions.interceptors.map(x => {
+                        if ((0, objects_1.isConstructor)(x)) {
+                            return async (ctx, next) => {
+                                const interceptor = moduleRef.get(x);
+                                if (typeof interceptor.intercept === 'function')
+                                    return interceptor.intercept(ctx, next);
+                            };
+                        }
+                        return x;
+                    });
+                }
+                return opraNestAdapter;
+            },
+        };
+        return {
+            global: moduleOptions.global,
+            module: OpraHttpCoreModule_1,
+            controllers: opraNestAdapter.nestControllers,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                adapterProvider,
+                {
+                    provide: opraHttpNestjsAdapterToken,
+                    useExisting: token,
+                },
+                {
+                    provide: core_1.APP_FILTER,
+                    useClass: opra_exception_filter_js_1.OpraExceptionFilter,
+                },
+            ],
+            imports: [...(moduleOptions?.imports || [])],
+            exports: [...(moduleOptions?.exports || []), adapterProvider],
+        };
+    }
+    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_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter])
+], OpraHttpCoreModule);

package/cjs/opra-http-nestjs-adapter.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpNestjsAdapter = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const objects_1 = require("@jsopen/objects");
+const common_1 = require("@nestjs/common");
+const common_2 = require("@opra/common");
+const http_1 = require("@opra/http");
+const nestjs_1 = require("@opra/nestjs");
+const ts_gems_1 = require("ts-gems");
+class OpraHttpNestjsAdapter extends http_1.HttpAdapter {
+    constructor(options) {
+        super(options);
+        this.nestControllers = [];
+        this._addRootController(options.schemaIsPublic);
+        if (options.controllers) {
+            for (const c of options.controllers) {
+                this._addToNestControllers(c, this.basePath, []);
+            }
+        }
+    }
+    async close() {
+        //
+    }
+    _addRootController(isPublic) {
+        const _this = this;
+        let RootController = class RootController {
+            schema(_req, next) {
+                _this.handler.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: this.basePath,
+            })
+        ], RootController);
+        if (isPublic) {
+            (0, nestjs_1.Public)()(RootController.prototype, 'schema', Object.getOwnPropertyDescriptor(RootController.prototype, 'schema'));
+        }
+        this.nestControllers.push(RootController);
+    }
+    _addToNestControllers(sourceClass, currentPath, parentTree) {
+        const metadata = Reflect.getMetadata(common_2.HTTP_CONTROLLER_METADATA, sourceClass);
+        if (!metadata)
+            return;
+        /** Create a new controller class */
+        const newClass = {
+            [sourceClass.name]: class extends sourceClass {
+            },
+        }[sourceClass.name];
+        /** Copy metadata keys from source class to new one */
+        nestjs_1.OpraNestUtils.copyDecoratorMetadata(newClass, ...parentTree);
+        (0, common_1.Controller)()(newClass);
+        const newPath = metadata.path
+            ? node_path_1.default.join(currentPath, metadata.path)
+            : currentPath;
+        const adapter = this;
+        // adapter.logger =
+        /** Disable default error handler. Errors will be handled by OpraExceptionFilter */
+        adapter.handler.onError = (context, error) => {
+            throw error;
+        };
+        this.nestControllers.push(newClass);
+        let metadataKeys;
+        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, _res) {
+                        _res.statusCode = 200;
+                        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.operation = operation;
+                        context.controller = operation.owner;
+                        context.controllerInstance = this;
+                        context.operationHandler = operationHandler;
+                        /** Handle request */
+                        await adapter.handler.handleRequest(context);
+                    },
+                });
+                /** Copy metadata keys from source function to new one */
+                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 = v.mergePath
+                    ? newPath + (v.path || '')
+                    : node_path_1.default.posix.join(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, objects_1.isConstructor)(child))
+                    throw new TypeError('Controllers should be injectable a class');
+                this._addToNestControllers(child, newPath, [
+                    ...parentTree,
+                    sourceClass,
+                ]);
+            }
+        }
+    }
+}
+exports.OpraHttpNestjsAdapter = OpraHttpNestjsAdapter;

package/cjs/opra-http.module.js

@@ -0,0 +1,33 @@
+"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
+     */
+    static forRoot(init) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [opra_http_core_module_js_1.OpraHttpCoreModule.forRoot(init)],
+        };
+    }
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [opra_http_core_module_js_1.OpraHttpCoreModule.forRootAsync(options)],
+        };
+    }
+};
+exports.OpraHttpModule = OpraHttpModule;
+exports.OpraHttpModule = OpraHttpModule = OpraHttpModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], OpraHttpModule);

package/cjs/opra-middleware.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraMiddleware = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const http_1 = require("@opra/http");
+const opra_http_nestjs_adapter_js_1 = require("./opra-http-nestjs-adapter.js");
+let OpraMiddleware = class OpraMiddleware {
+    constructor(opraAdapter) {
+        this.opraAdapter = opraAdapter;
+    }
+    use(req, res, next) {
+        const request = http_1.HttpIncoming.from(req);
+        const response = http_1.HttpOutgoing.from(res);
+        /** Create the HttpContext */
+        const context = new http_1.HttpContext({
+            adapter: this.opraAdapter,
+            platform: req.route ? 'express' : 'fastify',
+            request,
+            response,
+        });
+        req.opraContext = context;
+        this.opraAdapter
+            .emitAsync('createContext', context)
+            .then(() => next())
+            .catch(next);
+    }
+};
+exports.OpraMiddleware = OpraMiddleware;
+exports.OpraMiddleware = OpraMiddleware = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [opra_http_nestjs_adapter_js_1.OpraHttpNestjsAdapter])
+], OpraMiddleware);

package/cjs/package.json

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

package/esm/constants.js

@@ -0,0 +1 @@
+export const OPRA_HTTP_API_CONFIG = 'OPRA_HTTP_API_CONFIG';

package/esm/index.js

@@ -0,0 +1,7 @@
+import { IS_PUBLIC_KEY, OpraNestUtils, Public } from '@opra/nestjs';
+export * from './constants.js';
+export * from './opra-exception-filter.js';
+export * from './opra-http.module.js';
+export * from './opra-http-nestjs-adapter.js';
+export * from './opra-middleware.js';
+export { IS_PUBLIC_KEY, OpraNestUtils, Public };

package/esm/opra-exception-filter.js

@@ -0,0 +1,24 @@
+import { __decorate, __metadata } from "tslib";
+import { Catch } from '@nestjs/common';
+import { BaseExceptionFilter, ModuleRef } from '@nestjs/core';
+import { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
+let OpraExceptionFilter = class OpraExceptionFilter extends BaseExceptionFilter {
+    constructor(moduleRef) {
+        super();
+        this.moduleRef = moduleRef;
+    }
+    catch(exception, host) {
+        const ctx = host.switchToHttp().getRequest().opraContext;
+        if (ctx) {
+            const adapter = this.moduleRef.get(OpraHttpNestjsAdapter);
+            ctx.errors.push(exception);
+            return adapter.handler.sendResponse(ctx);
+        }
+        super.catch(exception, host);
+    }
+};
+OpraExceptionFilter = __decorate([
+    Catch(),
+    __metadata("design:paramtypes", [ModuleRef])
+], OpraExceptionFilter);
+export { OpraExceptionFilter };

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

@@ -0,0 +1,116 @@
+var OpraHttpCoreModule_1;
+import { __decorate, __metadata } from "tslib";
+import { isConstructor } from '@jsopen/objects';
+import { Global, Logger, Module, RequestMethod, } from '@nestjs/common';
+import { APP_FILTER, ModuleRef } from '@nestjs/core';
+import { ApiDocumentFactory } from '@opra/common';
+import { OPRA_HTTP_API_CONFIG } from './constants.js';
+import { OpraExceptionFilter } from './opra-exception-filter.js';
+import { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
+import { OpraMiddleware } from './opra-middleware.js';
+const opraHttpNestjsAdapterToken = Symbol('OpraHttpNestjsAdapter');
+let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
+    constructor(opraAdapter) {
+        this.opraAdapter = opraAdapter;
+    }
+    configure(consumer) {
+        consumer.apply(OpraMiddleware).forRoutes({
+            path: '*',
+            method: RequestMethod.ALL,
+        });
+    }
+    static forRoot(moduleOptions) {
+        return this._getDynamicModule({
+            ...moduleOptions,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                {
+                    provide: OPRA_HTTP_API_CONFIG,
+                    useValue: { ...moduleOptions },
+                },
+            ],
+        });
+    }
+    static forRootAsync(moduleOptions) {
+        if (!moduleOptions.useFactory)
+            throw new Error('Invalid configuration. Must provide "useFactory"');
+        return this._getDynamicModule({
+            ...moduleOptions,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                {
+                    provide: OPRA_HTTP_API_CONFIG,
+                    inject: moduleOptions.inject,
+                    useFactory: moduleOptions.useFactory,
+                },
+            ],
+        });
+    }
+    static _getDynamicModule(moduleOptions) {
+        const token = moduleOptions?.token || OpraHttpNestjsAdapter;
+        const opraNestAdapter = new OpraHttpNestjsAdapter({
+            ...moduleOptions,
+            interceptors: undefined,
+        });
+        const adapterProvider = {
+            provide: token,
+            inject: [ModuleRef, OPRA_HTTP_API_CONFIG],
+            useFactory: async (moduleRef, apiConfig) => {
+                opraNestAdapter.scope = apiConfig.scope;
+                opraNestAdapter.logger =
+                    opraNestAdapter.logger || new Logger(apiConfig.name);
+                opraNestAdapter._document =
+                    await ApiDocumentFactory.createDocument({
+                        ...apiConfig,
+                        api: {
+                            transport: 'http',
+                            name: apiConfig.name,
+                            description: apiConfig.description,
+                            controllers: moduleOptions.controllers,
+                        },
+                    });
+                if (moduleOptions.interceptors) {
+                    opraNestAdapter.interceptors = moduleOptions.interceptors.map(x => {
+                        if (isConstructor(x)) {
+                            return async (ctx, next) => {
+                                const interceptor = moduleRef.get(x);
+                                if (typeof interceptor.intercept === 'function')
+                                    return interceptor.intercept(ctx, next);
+                            };
+                        }
+                        return x;
+                    });
+                }
+                return opraNestAdapter;
+            },
+        };
+        return {
+            global: moduleOptions.global,
+            module: OpraHttpCoreModule_1,
+            controllers: opraNestAdapter.nestControllers,
+            providers: [
+                ...(moduleOptions?.providers || []),
+                adapterProvider,
+                {
+                    provide: opraHttpNestjsAdapterToken,
+                    useExisting: token,
+                },
+                {
+                    provide: APP_FILTER,
+                    useClass: OpraExceptionFilter,
+                },
+            ],
+            imports: [...(moduleOptions?.imports || [])],
+            exports: [...(moduleOptions?.exports || []), adapterProvider],
+        };
+    }
+    async onModuleDestroy() {
+        await this.opraAdapter.close();
+    }
+};
+OpraHttpCoreModule = OpraHttpCoreModule_1 = __decorate([
+    Module({}),
+    Global(),
+    __metadata("design:paramtypes", [OpraHttpNestjsAdapter])
+], OpraHttpCoreModule);
+export { OpraHttpCoreModule };

package/esm/opra-http-nestjs-adapter.js

@@ -0,0 +1,163 @@
+import { __decorate, __metadata, __param } from "tslib";
+import nodePath from 'node:path';
+import { isConstructor } from '@jsopen/objects';
+import { Controller, Delete, Get, Head, Next, Options, Patch, Post, Put, Req, Res, Search, } from '@nestjs/common';
+import { HTTP_CONTROLLER_METADATA, NotFoundError, } from '@opra/common';
+import { HttpAdapter } from '@opra/http';
+import { OpraNestUtils, Public } from '@opra/nestjs';
+import { asMutable } from 'ts-gems';
+export class OpraHttpNestjsAdapter extends HttpAdapter {
+    constructor(options) {
+        super(options);
+        this.nestControllers = [];
+        this._addRootController(options.schemaIsPublic);
+        if (options.controllers) {
+            for (const c of options.controllers) {
+                this._addToNestControllers(c, this.basePath, []);
+            }
+        }
+    }
+    async close() {
+        //
+    }
+    _addRootController(isPublic) {
+        const _this = this;
+        let RootController = class RootController {
+            schema(_req, next) {
+                _this.handler.sendDocumentSchema(_req.opraContext).catch(() => next());
+            }
+        };
+        __decorate([
+            Get('/\\$schema'),
+            __param(0, Req()),
+            __param(1, Next()),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object, Function]),
+            __metadata("design:returntype", void 0)
+        ], RootController.prototype, "schema", null);
+        RootController = __decorate([
+            Controller({
+                path: this.basePath,
+            })
+        ], RootController);
+        if (isPublic) {
+            Public()(RootController.prototype, 'schema', Object.getOwnPropertyDescriptor(RootController.prototype, 'schema'));
+        }
+        this.nestControllers.push(RootController);
+    }
+    _addToNestControllers(sourceClass, currentPath, parentTree) {
+        const metadata = Reflect.getMetadata(HTTP_CONTROLLER_METADATA, sourceClass);
+        if (!metadata)
+            return;
+        /** Create a new controller class */
+        const newClass = {
+            [sourceClass.name]: class extends sourceClass {
+            },
+        }[sourceClass.name];
+        /** Copy metadata keys from source class to new one */
+        OpraNestUtils.copyDecoratorMetadata(newClass, ...parentTree);
+        Controller()(newClass);
+        const newPath = metadata.path
+            ? nodePath.join(currentPath, metadata.path)
+            : currentPath;
+        const adapter = this;
+        // adapter.logger =
+        /** Disable default error handler. Errors will be handled by OpraExceptionFilter */
+        adapter.handler.onError = (context, error) => {
+            throw error;
+        };
+        this.nestControllers.push(newClass);
+        let metadataKeys;
+        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, _res) {
+                        _res.statusCode = 200;
+                        const api = adapter.document.api;
+                        const controller = api.findController(sourceClass);
+                        const operation = controller?.operations.get(k);
+                        const context = asMutable(_req.opraContext);
+                        if (!(context && operation && typeof operationHandler === 'function')) {
+                            throw new NotFoundError({
+                                message: `No endpoint found for [${_req.method}]${_req.baseUrl}`,
+                                details: {
+                                    path: _req.baseUrl,
+                                    method: _req.method,
+                                },
+                            });
+                        }
+                        /** Configure the HttpContext */
+                        context.operation = operation;
+                        context.controller = operation.owner;
+                        context.controllerInstance = this;
+                        context.operationHandler = operationHandler;
+                        /** Handle request */
+                        await adapter.handler.handleRequest(context);
+                    },
+                });
+                /** Copy metadata keys from source function to new one */
+                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);
+                }
+                Req()(newClass.prototype, k, 0);
+                Res()(newClass.prototype, k, 1);
+                const descriptor = Object.getOwnPropertyDescriptor(newClass.prototype, k);
+                const operationPath = v.mergePath
+                    ? newPath + (v.path || '')
+                    : nodePath.posix.join(newPath, v.path || '');
+                switch (v.method || 'GET') {
+                    case 'DELETE':
+                        /** Call @Delete decorator over new property */
+                        Delete(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'GET':
+                        /** Call @Get decorator over new property */
+                        Get(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'HEAD':
+                        /** Call @Head decorator over new property */
+                        Head(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'OPTIONS':
+                        /** Call @Options decorator over new property */
+                        Options(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'PATCH':
+                        /** Call @Patch decorator over new property */
+                        Patch(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'POST':
+                        /** Call @Post decorator over new property */
+                        Post(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'PUT':
+                        /** Call @Put decorator over new property */
+                        Put(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    case 'SEARCH':
+                        /** Call @Search decorator over new property */
+                        Search(operationPath)(newClass.prototype, k, descriptor);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        if (metadata.controllers) {
+            for (const child of metadata.controllers) {
+                if (!isConstructor(child))
+                    throw new TypeError('Controllers should be injectable a class');
+                this._addToNestControllers(child, newPath, [
+                    ...parentTree,
+                    sourceClass,
+                ]);
+            }
+        }
+    }
+}

package/esm/opra-http.module.js

@@ -0,0 +1,30 @@
+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
+     */
+    static forRoot(init) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [OpraHttpCoreModule.forRoot(init)],
+        };
+    }
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options) {
+        return {
+            module: OpraHttpModule_1,
+            imports: [OpraHttpCoreModule.forRootAsync(options)],
+        };
+    }
+};
+OpraHttpModule = OpraHttpModule_1 = __decorate([
+    Module({})
+], OpraHttpModule);
+export { OpraHttpModule };

package/esm/opra-middleware.js

@@ -0,0 +1,30 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@nestjs/common';
+import { HttpContext, HttpIncoming, HttpOutgoing } from '@opra/http';
+import { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
+let OpraMiddleware = class OpraMiddleware {
+    constructor(opraAdapter) {
+        this.opraAdapter = opraAdapter;
+    }
+    use(req, res, next) {
+        const request = HttpIncoming.from(req);
+        const response = HttpOutgoing.from(res);
+        /** Create the HttpContext */
+        const context = new HttpContext({
+            adapter: this.opraAdapter,
+            platform: req.route ? 'express' : 'fastify',
+            request,
+            response,
+        });
+        req.opraContext = context;
+        this.opraAdapter
+            .emitAsync('createContext', context)
+            .then(() => next())
+            .catch(next);
+    }
+};
+OpraMiddleware = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [OpraHttpNestjsAdapter])
+], OpraMiddleware);
+export { OpraMiddleware };

package/esm/package.json

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

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@opra/nestjs-http",
+  "version": "1.11.0",
+  "description": "Opra NestJS Http Module",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "@jsopen/objects": "^1.5.0",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@opra/common": "^1.11.0",
+    "@opra/core": "^1.11.0",
+    "@opra/nestjs": "^1.11.0",
+    "@opra/http": "^1.11.0",
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/nestjs-http"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "bin/",
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "nestjs",
+    "http"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/types/constants.d.ts

@@ -0,0 +1 @@
+export declare const OPRA_HTTP_API_CONFIG = "OPRA_HTTP_API_CONFIG";

package/types/index.d.cts

@@ -0,0 +1,7 @@
+import { IS_PUBLIC_KEY, OpraNestUtils, Public } from '@opra/nestjs';
+export * from './constants.js';
+export * from './opra-exception-filter.js';
+export * from './opra-http.module.js';
+export * from './opra-http-nestjs-adapter.js';
+export * from './opra-middleware.js';
+export { IS_PUBLIC_KEY, OpraNestUtils, Public };

package/types/index.d.ts

@@ -0,0 +1,7 @@
+import { IS_PUBLIC_KEY, OpraNestUtils, Public } from '@opra/nestjs';
+export * from './constants.js';
+export * from './opra-exception-filter.js';
+export * from './opra-http.module.js';
+export * from './opra-http-nestjs-adapter.js';
+export * from './opra-middleware.js';
+export { IS_PUBLIC_KEY, OpraNestUtils, Public };

package/types/opra-exception-filter.d.ts

@@ -0,0 +1,7 @@
+import { type ArgumentsHost } from '@nestjs/common';
+import { BaseExceptionFilter, ModuleRef } from '@nestjs/core';
+export declare class OpraExceptionFilter extends BaseExceptionFilter {
+    private moduleRef;
+    constructor(moduleRef: ModuleRef);
+    catch(exception: any, host: ArgumentsHost): Promise<void> | undefined;
+}

package/types/opra-http-core.module.d.ts

@@ -0,0 +1,12 @@
+import { type DynamicModule, type MiddlewareConsumer, type NestModule, type OnModuleDestroy } from '@nestjs/common';
+import type { OpraHttpModule } from './opra-http.module.js';
+import { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
+export declare class OpraHttpCoreModule implements OnModuleDestroy, NestModule {
+    protected opraAdapter: OpraHttpNestjsAdapter;
+    constructor(opraAdapter: OpraHttpNestjsAdapter);
+    configure(consumer: MiddlewareConsumer): void;
+    static forRoot(moduleOptions: OpraHttpModule.ModuleOptions): DynamicModule;
+    static forRootAsync(moduleOptions: OpraHttpModule.AsyncModuleOptions): DynamicModule;
+    protected static _getDynamicModule(moduleOptions: OpraHttpModule.ModuleOptions | OpraHttpModule.AsyncModuleOptions): DynamicModule;
+    onModuleDestroy(): Promise<void>;
+}

package/types/opra-http-nestjs-adapter.d.ts

@@ -0,0 +1,12 @@
+import { type Type } from '@nestjs/common';
+import { HttpAdapter } from '@opra/http';
+export declare class OpraHttpNestjsAdapter extends HttpAdapter {
+    readonly nestControllers: Type[];
+    constructor(options: HttpAdapter.Options & {
+        schemaIsPublic?: boolean;
+        controllers?: Type[];
+    });
+    close(): Promise<void>;
+    protected _addRootController(isPublic?: boolean): void;
+    protected _addToNestControllers(sourceClass: Type, currentPath: string, parentTree: Type[]): void;
+}

package/types/opra-http.module.d.ts

@@ -0,0 +1,36 @@
+import { type DynamicModule, Logger, type Type } from '@nestjs/common';
+import type { ApiDocumentFactory } from '@opra/common';
+import type { HttpAdapter } from '@opra/http';
+export declare namespace OpraHttpModule {
+    export interface ModuleOptions extends BaseModuleOptions, ApiConfig {
+    }
+    export interface AsyncModuleOptions extends BaseModuleOptions {
+        inject?: any[];
+        useFactory?: (...args: any[]) => Promise<ApiConfig> | ApiConfig;
+    }
+    interface BaseModuleOptions extends Pick<DynamicModule, 'imports' | 'providers' | 'exports' | 'controllers' | 'global'> {
+        token?: any;
+        basePath?: string;
+        schemaIsPublic?: boolean;
+        interceptors?: (HttpAdapter.InterceptorFunction | HttpAdapter.IHttpInterceptor | Type<HttpAdapter.IHttpInterceptor>)[];
+    }
+    export interface ApiConfig extends Pick<ApiDocumentFactory.InitArguments, 'types' | 'references' | 'info'> {
+        name: string;
+        description?: string;
+        scope?: string;
+        logger?: Logger;
+    }
+    export {};
+}
+export declare class OpraHttpModule {
+    /**
+     *
+     * @param init
+     */
+    static forRoot(init: OpraHttpModule.ModuleOptions): DynamicModule;
+    /**
+     *
+     * @param options
+     */
+    static forRootAsync(options: OpraHttpModule.AsyncModuleOptions): DynamicModule;
+}

package/types/opra-middleware.d.ts

@@ -0,0 +1,8 @@
+import { type NestMiddleware } from '@nestjs/common';
+import type { NextFunction, Request, Response } from 'express';
+import { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
+export declare class OpraMiddleware implements NestMiddleware {
+    protected opraAdapter: OpraHttpNestjsAdapter;
+    constructor(opraAdapter: OpraHttpNestjsAdapter);
+    use(req: Request, res: Response, next: NextFunction): void;
+}