@opra/nestjs-http 1.28.5 → 1.29.1

package/README.md

@@ -65,7 +65,7 @@ OpraHttpModule.forRootAsync({
     controllers: [UsersController],
   }),
   inject: [ConfigService],
-})
+});
 ```
 
 ## Node Compatibility

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';
 /**
@@ -26,6 +28,10 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
     constructor(options) {
         super(options);
         this._addRootController(options.schemaIsPublic);
+        /* Disable default error handler. Errors will be handled by OpraExceptionFilter */
+        this.on('error', (error) => {
+            throw error;
+        });
         if (options.controllers) {
             for (const c of options.controllers) {
                 this._addToNestControllers(c, this.basePath, []);
@@ -39,6 +45,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 +74,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 +99,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,
@@ -96,11 +145,6 @@ export class OpraHttpNestjsAdapter extends HttpAdapter {
             ? nodePath.posix.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) {
@@ -115,7 +159,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 +177,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,19 +1,19 @@
 {
   "name": "@opra/nestjs-http",
-  "version": "1.28.5",
+  "version": "1.29.1",
   "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.5",
-    "@opra/core": "^1.28.5",
-    "@opra/nestjs": "^1.28.5",
-    "@opra/http": "^1.28.5",
+    "@opra/common": "^1.29.1",
+    "@opra/core": "^1.29.1",
+    "@opra/nestjs": "^1.29.1",
+    "@opra/http": "^1.29.1",
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0"
   },