@opra/nestjs-http 1.28.4 → 1.29.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Panates
+Copyright (c) 2020-present 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

package/README.md

@@ -1,19 +1,79 @@
+<div align="center">
+
+<a href="https://oprajs.com">
+  <img src="https://oprajs.com/img/opra-header-block.webp" width="880" alt="OPRA — Open Platform for Rich APIs" />
+</a>
+
 # @opra/nestjs-http
 
+NestJS HTTP module for the OPRA framework
+
 [![NPM Version][npm-image]][npm-url]
 [![NPM Downloads][downloads-image]][downloads-url]
 [![CI Tests][ci-test-image]][ci-test-url]
 [![Test Coverage][coveralls-image]][coveralls-url]
 
+[🌐 Documentation](https://oprajs.com) · [🚀 Getting Started](https://oprajs.com/docs/introduction) · [📦 Packages](https://github.com/panates/opra#packages) · [💬 Issues](https://github.com/panates/opra/issues)
+
+</div>
+
+---
+
+NestJS HTTP module for the [OPRA](https://oprajs.com) framework. Register your OPRA API inside a NestJS application in a few lines.
+
+## Features
+
+- **`OpraHttpModule`** — Dynamically configurable NestJS module (`forRoot` / `forRootAsync`)
+- **`OpraHttpNestjsAdapter`** — NestJS adapter integrating OPRA's HTTP handler
+- **`OpraExceptionFilter`** — Global exception filter that maps OPRA errors to HTTP responses
+- **`OpraMiddleware`** — Request/response middleware for the OPRA pipeline
+- Full support for NestJS **dependency injection**, **interceptors**, and **guards**
+
+## Installation
 
-## Support
-You can report bugs and discuss features on the [GitHub issues](https://github.com/panates/opra/issues) page.
+```bash
+npm install @opra/nestjs-http
+```
+
+## Usage
+
+```typescript
+import { Module } from '@nestjs/common';
+import { OpraHttpModule } from '@opra/nestjs-http';
+
+@Module({
+  imports: [
+    OpraHttpModule.forRoot({
+      name: 'MyAPI',
+      basePath: 'v1',
+      schemaIsPublic: true,
+      controllers: [UsersController, ProductsController],
+      providers: [UsersService, ProductsService],
+      types: [User, Product],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Async configuration
+
+```typescript
+OpraHttpModule.forRootAsync({
+  useFactory: (config: ConfigService) => ({
+    name: config.get('API_NAME'),
+    controllers: [UsersController],
+  }),
+  inject: [ConfigService],
+});
+```
 
 ## Node Compatibility
-- node >= 20.x
 
+- node >= 20.x
 
 ## License
+
 Available under [MIT](LICENSE) license.
 
 [npm-image]: https://img.shields.io/npm/v/@opra/nestjs-http

package/opra-exception-filter.js

@@ -27,7 +27,7 @@ let OpraExceptionFilter = class OpraExceptionFilter extends BaseExceptionFilter
         if (ctx) {
             const adapter = this.moduleRef.get(OpraHttpNestjsAdapter);
             ctx.errors.push(exception);
-            return adapter.handler.sendResponse(ctx);
+            return adapter.sendResponse(ctx);
         }
         super.catch(exception, host);
     }

package/opra-http-core.module.js

@@ -2,7 +2,7 @@ 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 { APP_FILTER, HttpAdapterHost, ModuleRef } from '@nestjs/core';
 import { ApiDocumentFactory } from '@opra/common';
 import { HttpAdapter, HttpContext } from '@opra/http';
 import { OPRA_HTTP_API_CONFIG } from './constants.js';
@@ -56,8 +56,8 @@ let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
         });
         const adapterProvider = {
             provide: token,
-            inject: [ModuleRef, OPRA_HTTP_API_CONFIG],
-            useFactory: async (moduleRef, apiConfig) => {
+            inject: [ModuleRef, HttpAdapterHost, OPRA_HTTP_API_CONFIG],
+            useFactory: async (moduleRef, httpAdapterHost, apiConfig) => {
                 opraNestAdapter.scope = apiConfig.scope;
                 opraNestAdapter.logger =
                     opraNestAdapter.logger || new Logger(apiConfig.name);
@@ -83,6 +83,11 @@ let OpraHttpCoreModule = OpraHttpCoreModule_1 = class OpraHttpCoreModule {
                         return x;
                     });
                 }
+                opraNestAdapter.setHttpHandler((req, res) => {
+                    const httpInstance = httpAdapterHost.httpAdapter?.getInstance();
+                    if (httpInstance)
+                        httpInstance(req, res);
+                });
                 return opraNestAdapter;
             },
         };

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

@@ -1,5 +1,8 @@
+import * as http from 'node:http';
+import { type IncomingMessage, type ServerResponse } from 'node:http';
 import { type Type } from '@nestjs/common';
-import { HttpAdapter } from '@opra/http';
+import { HttpController, HttpOperation } from '@opra/common';
+import { HttpAdapter, HttpContext } from '@opra/http';
 /**
  * OpraHttpNestjsAdapter
  *
@@ -28,6 +31,15 @@ export declare class OpraHttpNestjsAdapter extends HttpAdapter {
      * @returns {Promise<void>}
      */
     close(): Promise<void>;
+    createContext(_req: any, _res: any, args?: {
+        controller?: HttpController;
+        controllerInstance?: any;
+        operation?: HttpOperation;
+        operationHandler: Function;
+    }): Promise<HttpContext>;
+    protected _httpHandler?: (req: IncomingMessage, res: ServerResponse) => void;
+    setHttpHandler(handler: (req: IncomingMessage, res: ServerResponse) => void): void;
+    handleRawRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
     /**
      * Adds the root controller that serves the OPRA schema.
      *

package/opra-http-nestjs-adapter.js

@@ -1,9 +1,11 @@
 import { __decorate, __metadata, __param } from "tslib";
+import * as http from 'node:http';
+import {} from 'node:http';
 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, HttpApi, HttpController, NotFoundError, } from '@opra/common';
-import { HttpAdapter, HttpContext } from '@opra/http';
+import { Controller, Delete, Get, Head, HttpCode, Next, Options, Patch, Post, Put, Req, Res, Search, } from '@nestjs/common';
+import { HTTP_CONTROLLER_METADATA, HttpApi, HttpController, HttpOperation, NotFoundError, } from '@opra/common';
+import { HttpAdapter, HttpBundle, HttpContext, HttpRequest, HttpResponse, } from '@opra/http';
 import { OpraNestUtils, Public } from '@opra/nestjs';
 import { asMutable } from 'ts-gems';
 /**
@@ -39,6 +41,25 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
     async close() {
         //
     }
+    async createContext(_req, _res, args) {
+        const ctx = await super.createContext(_req, _res, args);
+        // @ts-ignore
+        ctx.platform = _req.route ? 'express' : 'fastify';
+        return ctx;
+    }
+    _httpHandler;
+    setHttpHandler(handler) {
+        this._httpHandler = handler;
+    }
+    async handleRawRequest(req, res) {
+        if (!this._httpHandler)
+            throw new Error('HTTP handler is not initialized. Call setHttpHandler() first.');
+        return new Promise((resolve, reject) => {
+            res.once('finish', resolve);
+            res.once('error', reject);
+            this._httpHandler(req, res);
+        });
+    }
     /**
      * Adds the root controller that serves the OPRA schema.
      *
@@ -49,7 +70,21 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
         const _this = this;
         let RootController = class RootController {
             schema(_req, next) {
-                _this.handler.sendDocumentSchema(_req.opraContext).catch(() => next());
+                _this.sendDocumentSchema(_req.opraContext).catch(() => next());
+            }
+            bundle(_req, _res, next) {
+                Promise.resolve()
+                    .then(async () => {
+                    const bundle = new HttpBundle({
+                        __adapter: _this,
+                        platform: _req.route ? 'express' : 'fastify',
+                        request: HttpRequest.create(_req),
+                        response: HttpResponse.create(_res),
+                    });
+                    await _this.emitAsync('create-bundle', bundle);
+                    await _this.handleBundle(bundle);
+                })
+                    .catch(() => next());
             }
         };
         __decorate([
@@ -60,6 +95,16 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
             __metadata("design:paramtypes", [Object, Function]),
             __metadata("design:returntype", void 0)
         ], RootController.prototype, "schema", null);
+        __decorate([
+            Post('/\\$bundle'),
+            HttpCode(200),
+            __param(0, Req()),
+            __param(1, Res()),
+            __param(2, Next()),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object, Object, Function]),
+            __metadata("design:returntype", void 0)
+        ], RootController.prototype, "bundle", null);
         RootController = __decorate([
             Controller({
                 path: this.basePath,
@@ -98,9 +143,9 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
         const adapter = this;
         // adapter.logger =
         /* Disable default error handler. Errors will be handled by OpraExceptionFilter */
-        adapter.handler.onError = (context, error) => {
+        adapter.on('error', (error) => {
             throw error;
-        };
+        });
         this.nestControllers.push(newClass);
         let metadataKeys;
         if (metadata.operations) {
@@ -115,7 +160,9 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
                         const controller = api.findController(sourceClass);
                         const operation = controller?.operations.get(k);
                         const context = asMutable(_req.opraContext);
-                        if (!(context && operation && typeof operationHandler === 'function')) {
+                        if (!(context &&
+                            operation &&
+                            typeof operationHandler === 'function')) {
                             throw new NotFoundError({
                                 message: `No endpoint found for [${_req.method}]${_req.baseUrl}`,
                                 details: {
@@ -131,7 +178,7 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
                         context.__controller = this;
                         context.__handler = operationHandler;
                         /* Handle request */
-                        await adapter.handler.handleRequest(context);
+                        await adapter.handleRequest(context);
                     },
                 });
                 /* Copy metadata keys from source function to new one */

package/opra-middleware.js

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from "tslib";
 import { Injectable } from '@nestjs/common';
-import { HttpContext, HttpIncoming, HttpOutgoing } from '@opra/http';
+import { HttpRequest, HttpResponse } from '@opra/http';
 import { OpraHttpNestjsAdapter } from './opra-http-nestjs-adapter.js';
 /**
  * OpraMiddleware
@@ -21,19 +21,18 @@ let OpraMiddleware = class OpraMiddleware {
      * @param next - Function that calls the next middleware.
      */
     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;
+        const request = HttpRequest.create(req);
+        const response = HttpResponse.create(res);
         this.opraAdapter
-            .emitAsync('createContext', context)
-            .then(() => next())
+            .createContext(request, response)
+            .then(async (context) => {
+            // @ts-ignore
+            context.platform = req.route ? 'express' : 'fastify';
+            req.opraContext = context;
+            await this.opraAdapter
+                .emitAsync('createContext', context)
+                .then(() => next());
+        })
             .catch(next);
     }
 };

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@opra/nestjs-http",
-  "version": "1.28.4",
+  "version": "1.29.0",
   "description": "Opra NestJS Http Module",
   "author": "Panates",
   "license": "MIT",
+  "homepage": "https://www.oprajs.com",
   "dependencies": {
-    "@jsopen/objects": "^2.2.2",
+    "@jsopen/objects": "^2.2.3",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@opra/common": "^1.28.4",
-    "@opra/core": "^1.28.4",
-    "@opra/nestjs": "^1.28.4",
-    "@opra/http": "^1.28.4",
+    "@opra/common": "^1.29.0",
+    "@opra/core": "^1.29.0",
+    "@opra/nestjs": "^1.29.0",
+    "@opra/http": "^1.29.0",
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0"
   },