@opra/http 1.21.0 → 1.22.0

package/{esm/express-adapter.js → express-adapter.js}

@@ -6,9 +6,10 @@ import { HttpContext } from './http-context.js';
 import { HttpIncoming } from './interfaces/http-incoming.interface.js';
 import { HttpOutgoing } from './interfaces/http-outgoing.interface.js';
 export class ExpressAdapter extends HttpAdapter {
+    app;
+    _controllerInstances = new Map();
     constructor(app, document, options) {
         super(options);
-        this._controllerInstances = new Map();
         this.app = app;
         if (!(document.api instanceof HttpApi))
             throw new TypeError(`The document does not expose an HTTP Api`);

package/{esm/http-adapter.js → http-adapter.js}

@@ -5,9 +5,13 @@ import { HttpHandler } from './http-handler.js';
  * @class HttpAdapter
  */
 export class HttpAdapter extends PlatformAdapter {
+    handler;
+    transform = 'http';
+    basePath;
+    scope;
+    interceptors;
     constructor(options) {
         super(options);
-        this.transform = 'http';
         this.handler = new HttpHandler(this);
         this.interceptors = [...(options?.interceptors || [])];
         this.basePath = options?.basePath || '/';

package/{esm/http-context.js → http-context.js}

@@ -3,6 +3,16 @@ import { InternalServerError, NotAcceptableError, } from '@opra/common';
 import { ExecutionContext, kAssetCache } from '@opra/core';
 import { MultipartReader } from './impl/multipart-reader.js';
 export class HttpContext extends ExecutionContext {
+    _body;
+    _multipartReader;
+    request;
+    response;
+    mediaType;
+    cookies;
+    headers;
+    pathParams;
+    queryParams;
+    errors = [];
     constructor(init) {
         super({
             ...init,
@@ -11,7 +21,6 @@ export class HttpContext extends ExecutionContext {
                 init.__adapter.document.node,
             transport: 'http',
         });
-        this.errors = [];
         if (init.__contDef)
             this.__contDef = init.__contDef;
         if (init.__controller)

package/{esm/http-handler.js → http-handler.js}

@@ -12,6 +12,9 @@ import { wrapException } from './utils/wrap-exception.js';
  * @class HttpHandler
  */
 export class HttpHandler {
+    adapter;
+    [kAssetCache];
+    onError;
     constructor(adapter) {
         this.adapter = adapter;
         this[kAssetCache] = adapter[kAssetCache];

package/{esm/impl → impl}/http-incoming.host.js

@@ -8,6 +8,7 @@ import fresh from 'fresh';
 import parseRange from 'range-parser';
 import { BodyReader } from '../utils/body-reader.js';
 export class HttpIncomingHost {
+    body;
     get protocol() {
         const proto = this.header('X-Forwarded-Proto') || 'http';
         const index = proto.indexOf(',');

package/{esm/impl → impl}/multipart-reader.js

@@ -9,15 +9,20 @@ import { EventEmitter } from 'events';
 import fsPromise from 'fs/promises';
 import { isNotNullish } from 'valgen';
 export class MultipartReader extends EventEmitter {
+    context;
+    mediaType;
+    _started = false;
+    _finished = false;
+    _cancelled = false;
+    _form;
+    _items = [];
+    _stack = [];
+    tempDirectory;
+    scope;
     constructor(context, options, mediaType) {
         super();
         this.context = context;
         this.mediaType = mediaType;
-        this._started = false;
-        this._finished = false;
-        this._cancelled = false;
-        this._items = [];
-        this._stack = [];
         this.setMaxListeners(1000);
         this.tempDirectory = options?.tempDirectory || os.tmpdir();
         this.scope = options?.scope;

package/{esm/impl → impl}/node-incoming-message.host.js

@@ -13,12 +13,23 @@ export const kHttpParser = Symbol.for('kHttpParser');
  * @class NodeIncomingMessageHost
  */
 export class NodeIncomingMessageHost extends Duplex {
+    [kHeaders];
+    [kHeadersDistinct];
+    [kTrailers];
+    [kTrailersDistinct];
+    [kHttpParser];
+    _readStream;
+    rawHeaders = [];
+    rawTrailers = [];
+    params;
+    cookies;
+    body;
+    complete = false;
+    ip;
+    ips;
+    joinDuplicateHeaders = false;
     constructor(init) {
         super();
-        this.rawHeaders = [];
-        this.rawTrailers = [];
-        this.complete = false;
-        this.joinDuplicateHeaders = false;
         if (init) {
             this.complete = true;
             this.httpVersionMajor = init.httpVersionMajor || 1;

package/{esm/impl → impl}/node-outgoing-message.host.js

@@ -12,10 +12,15 @@ export const kOutTrailers = Symbol.for('kOutTrailers');
  * @class NodeOutgoingMessageHost
  */
 export class NodeOutgoingMessageHost extends Duplex {
+    [kOutHeaders];
+    [kOutTrailers];
+    _headersSent = false;
+    _httpVersionMajor;
+    _httpVersionMinor;
+    finished = false;
+    body;
     constructor(init) {
         super();
-        this._headersSent = false;
-        this.finished = false;
         if (init) {
             this.req = init.req;
             this.statusCode = init?.statusCode || 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/http",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "Opra Http Server Adapter",
   "author": "Panates",
   "license": "MIT",
@@ -19,11 +19,11 @@
     "cookie-signature": "^1.2.2",
     "encodeurl": "^2.0.0",
     "expect": "^30.2.0",
-    "fast-tokenizer": "^1.7.0",
+    "fast-tokenizer": "^1.8.0",
     "fresh": "^0.5.2",
-    "iconv-lite": "^0.7.0",
+    "iconv-lite": "^0.7.1",
     "mime-types": "^3.0.2",
-    "node-events-async": "^1.2.0",
+    "node-events-async": "^1.4.0",
     "power-tasks": "^1.11.1",
     "putil-varhelpers": "^1.6.5",
     "range-parser": "^1.2.1",
@@ -35,48 +35,31 @@
     "vary": "^1.1.2"
   },
   "peerDependencies": {
-    "@opra/common": "^1.21.0",
-    "@opra/core": "^1.21.0"
+    "@opra/common": "^1.22.0",
+    "@opra/core": "^1.22.0"
   },
   "optionalDependencies": {
     "express": "^4.0.0 || ^5.0.0",
     "fastify": "^4.0.0 || ^5.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"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./cjs/index.js",
-  "module": "./esm/index.js",
-  "types": "./types/index.d.ts",
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/panates/opra.git",
     "directory": "packages/http"
   },
-  "engines": {
-    "node": ">=16.0",
-    "npm": ">=7.0.0"
-  },
-  "files": [
-    "cjs/",
-    "esm/",
-    "i18n/",
-    "types/",
-    "LICENSE",
-    "README.md"
-  ],
   "keywords": [
     "opra",
     "rest",

package/{esm/utils → utils}/body-reader.js

@@ -12,11 +12,19 @@ import * as zlib from 'zlib';
  * @class BodyReader
  */
 export class BodyReader extends EventEmitter {
+    req;
+    limit;
+    _stream;
+    _buffer;
+    _completed = false;
+    _receivedSize = 0;
+    cleanup;
+    onAborted;
+    onData;
+    onEnd;
     constructor(req, options) {
         super();
         this.req = req;
-        this._completed = false;
-        this._receivedSize = 0;
         this.onAborted = () => this._onAborted();
         this.onData = (chunk) => this._onData(chunk);
         this.onEnd = (err) => this._onEnd(err);

package/cjs/express-adapter.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressAdapter = void 0;
-const tslib_1 = require("tslib");
-const nodePath = tslib_1.__importStar(require("node:path"));
-const common_1 = require("@opra/common");
-const express_1 = require("express");
-const http_adapter_js_1 = require("./http-adapter.js");
-const http_context_js_1 = require("./http-context.js");
-const http_incoming_interface_js_1 = require("./interfaces/http-incoming.interface.js");
-const http_outgoing_interface_js_1 = require("./interfaces/http-outgoing.interface.js");
-class ExpressAdapter extends http_adapter_js_1.HttpAdapter {
-    constructor(app, document, options) {
-        super(options);
-        this._controllerInstances = new Map();
-        this.app = app;
-        if (!(document.api instanceof common_1.HttpApi))
-            throw new TypeError(`The document does not expose an HTTP Api`);
-        this._document = document;
-        for (const c of this.api.controllers.values())
-            this._createControllers(c);
-        this._initRouter();
-    }
-    get platform() {
-        return 'express';
-    }
-    async close() {
-        const processInstance = async (controller) => {
-            if (controller.controllers.size) {
-                const subResources = Array.from(controller.controllers.values());
-                subResources.reverse();
-                for (const subResource of subResources) {
-                    await processInstance(subResource);
-                }
-            }
-        };
-        for (const c of this.api.controllers.values())
-            await processInstance(c);
-        this._controllerInstances.clear();
-    }
-    getControllerInstance(controllerPath) {
-        const controller = this.api.findController(controllerPath);
-        return controller && this._controllerInstances.get(controller);
-    }
-    _initRouter() {
-        const router = (0, express_1.Router)();
-        this.app.use(this.basePath, router);
-        const createContext = async (_req, _res, args) => {
-            const request = http_incoming_interface_js_1.HttpIncoming.from(_req);
-            const response = http_outgoing_interface_js_1.HttpOutgoing.from(_res);
-            const ctx = new http_context_js_1.HttpContext({
-                __adapter: this,
-                platform: this.platform,
-                request,
-                response,
-                __contDef: args?.controller,
-                __controller: args?.controllerInstance,
-                __oprDef: args?.operation,
-                __handler: args?.operationHandler,
-            });
-            await this.emitAsync('createContext', ctx);
-            return ctx;
-        };
-        /** Add an endpoint that returns document schema */
-        router.get('/\\$schema', (_req, _res, next) => {
-            createContext(_req, _res)
-                .then(ctx => this.handler.sendDocumentSchema(ctx).catch(next))
-                .catch(next);
-        });
-        /** Add operation endpoints */
-        if (this.api.controllers.size) {
-            const processResource = (controller, currentPath) => {
-                currentPath = nodePath.posix.join(currentPath, controller.path);
-                for (const operation of controller.operations.values()) {
-                    const routePath = currentPath + (operation.path || '');
-                    const controllerInstance = this._controllerInstances.get(controller);
-                    const operationHandler = controllerInstance[operation.name];
-                    if (!operationHandler)
-                        continue;
-                    /** Define router callback */
-                    router[operation.method.toLowerCase()](routePath, (_req, _res, _next) => {
-                        createContext(_req, _res, {
-                            controller,
-                            controllerInstance,
-                            operation,
-                            operationHandler,
-                        })
-                            .then(ctx => this.handler.handleRequest(ctx))
-                            .then(() => {
-                            if (!_res.headersSent)
-                                _next();
-                        })
-                            .catch((e) => this.emit('error', e));
-                    });
-                }
-                if (controller.controllers.size) {
-                    for (const child of controller.controllers.values())
-                        processResource(child, currentPath);
-                }
-            };
-            for (const c of this.api.controllers.values())
-                processResource(c, '/');
-        }
-        /** Add an endpoint that returns 404 error at last */
-        router.use('/{*splat}', (_req, _res, next) => {
-            createContext(_req, _res)
-                .then(ctx => {
-                ctx.errors.push(new common_1.NotFoundError({
-                    message: `No endpoint found at [${_req.method}]${_req.baseUrl}`,
-                    details: {
-                        path: _req.baseUrl,
-                        method: _req.method,
-                    },
-                }));
-                this.handler.sendResponse(ctx).catch(next);
-            })
-                .catch(next);
-        });
-    }
-    _createControllers(controller) {
-        let instance = controller.instance;
-        if (!instance && controller.ctor)
-            instance = new controller.ctor();
-        if (instance) {
-            this._controllerInstances.set(controller, instance);
-            // Initialize sub resources
-            for (const r of controller.controllers.values()) {
-                this._createControllers(r);
-            }
-        }
-        return instance;
-    }
-}
-exports.ExpressAdapter = ExpressAdapter;

package/cjs/http-adapter.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpAdapter = void 0;
-const core_1 = require("@opra/core");
-const http_handler_js_1 = require("./http-handler.js");
-/**
- *
- * @class HttpAdapter
- */
-class HttpAdapter extends core_1.PlatformAdapter {
-    constructor(options) {
-        super(options);
-        this.transform = 'http';
-        this.handler = new http_handler_js_1.HttpHandler(this);
-        this.interceptors = [...(options?.interceptors || [])];
-        this.basePath = options?.basePath || '/';
-        if (!this.basePath.startsWith('/'))
-            this.basePath = '/' + this.basePath;
-        this.scope = options?.scope;
-    }
-    get api() {
-        return this.document.getHttpApi();
-    }
-}
-exports.HttpAdapter = HttpAdapter;

package/cjs/http-context.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpContext = void 0;
-const tslib_1 = require("tslib");
-const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
-const common_1 = require("@opra/common");
-const core_1 = require("@opra/core");
-const multipart_reader_js_1 = require("./impl/multipart-reader.js");
-class HttpContext extends core_1.ExecutionContext {
-    constructor(init) {
-        super({
-            ...init,
-            __docNode: init.__oprDef?.node ||
-                init.__contDef?.node ||
-                init.__adapter.document.node,
-            transport: 'http',
-        });
-        this.errors = [];
-        if (init.__contDef)
-            this.__contDef = init.__contDef;
-        if (init.__controller)
-            this.__controller = init.__controller;
-        if (init.__oprDef)
-            this.__oprDef = init.__oprDef;
-        if (init.__handler)
-            this.__handler = init.__handler;
-        this.request = init.request;
-        this.response = init.response;
-        this.mediaType = init.mediaType;
-        this.cookies = init.cookies || {};
-        this.headers = init.headers || {};
-        this.pathParams = init.pathParams || {};
-        this.queryParams = init.queryParams || {};
-        this._body = init.body;
-        this.on('finish', () => {
-            if (this._multipartReader)
-                this._multipartReader.purge().catch(() => undefined);
-        });
-    }
-    get isMultipart() {
-        return !!this.request.is('multipart');
-    }
-    async getMultipartReader() {
-        if (!this.isMultipart)
-            throw new common_1.InternalServerError('Request content is not a multipart content');
-        if (this._multipartReader)
-            return this._multipartReader;
-        const { mediaType } = this;
-        if (mediaType?.contentType) {
-            const arr = Array.isArray(mediaType.contentType)
-                ? mediaType.contentType
-                : [mediaType.contentType];
-            const contentType = arr.find(ct => type_is_1.default.is(ct, ['multipart']));
-            if (!contentType)
-                throw new common_1.NotAcceptableError('This endpoint does not accept multipart requests');
-        }
-        const reader = new multipart_reader_js_1.MultipartReader(this, {
-            limits: {
-                fields: mediaType?.maxFields,
-                fieldSize: mediaType?.maxFieldsSize,
-                files: mediaType?.maxFiles,
-                fileSize: mediaType?.maxFileSize,
-            },
-        }, mediaType);
-        this._multipartReader = reader;
-        return reader;
-    }
-    async getBody() {
-        if (this._body !== undefined)
-            return this._body;
-        const { request, __oprDef, mediaType } = this;
-        if (this.isMultipart) {
-            const reader = await this.getMultipartReader();
-            /** Retrieve all fields */
-            const parts = await reader.getAll();
-            /** Filter fields according to configuration */
-            this._body = [...parts];
-            return this._body;
-        }
-        this._body = await this.request.readBody({
-            limit: __oprDef?.requestBody?.maxContentSize,
-        });
-        if (this._body != null) {
-            // Convert Buffer to string if media is text
-            if (Buffer.isBuffer(this._body) &&
-                request.is(['json', 'xml', 'txt', 'text'])) {
-                this._body = this._body.toString('utf-8');
-            }
-            // Transform text to Object if media is JSON
-            if (typeof this._body === 'string' && request.is(['json']))
-                this._body = JSON.parse(this._body);
-        }
-        if (mediaType) {
-            // Decode/Validate the data object according to data model
-            if (this._body && mediaType.type) {
-                let decode = this.__adapter[core_1.kAssetCache].get(mediaType, 'decode');
-                if (!decode) {
-                    decode = mediaType.generateCodec('decode', {
-                        scope: this.__adapter.scope,
-                        partial: __oprDef?.requestBody?.partial,
-                        projection: '*',
-                        ignoreReadonlyFields: true,
-                        allowPatchOperators: __oprDef?.requestBody?.allowPatchOperators,
-                        keepKeyFields: __oprDef?.requestBody?.keepKeyFields,
-                    });
-                    this.__adapter[core_1.kAssetCache].set(mediaType, 'decode', decode);
-                }
-                this._body = decode(this._body);
-            }
-        }
-        return this._body;
-    }
-}
-exports.HttpContext = HttpContext;