@opra/core 1.0.0-alpha.3 → 1.0.0-alpha.31

package/esm/http/impl/http-incoming.host.js

@@ -2,10 +2,10 @@
   Some parts of this file contains codes from open source express library
   https://github.com/expressjs
  */
+import typeIs from '@browsery/type-is';
 import accepts from 'accepts';
 import fresh from 'fresh';
 import parseRange from 'range-parser';
-import typeIs from '@browsery/type-is';
 import { BodyReader } from '../utils/body-reader.js';
 export class HttpIncomingHost {
     get protocol() {
@@ -37,11 +37,11 @@ export class HttpIncomingHost {
     get fresh() {
         const method = this.method;
         // GET or HEAD for weak freshness validation only
-        if ('GET' !== method && 'HEAD' !== method)
+        if (method !== 'GET' && method !== 'HEAD')
             return false;
         const status = this.res?.statusCode;
         // 2xx or 304 as per rfc2616 14.26
-        if ((status >= 200 && status < 300) || 304 === status) {
+        if ((status >= 200 && status < 300) || status === 304) {
             return fresh(this.headers, {
                 etag: this.res.getHeader('ETag'),
                 'last-modified': this.res.getHeader('Last-Modified'),

package/esm/http/impl/http-outgoing.host.js

@@ -2,6 +2,7 @@
   Some parts of this file contains codes from open source express library
   https://github.com/expressjs
  */
+import { HttpStatusCode } from '@opra/common';
 import contentDisposition from 'content-disposition';
 import contentType from 'content-type';
 import cookie from 'cookie';
@@ -11,7 +12,6 @@ import mime from 'mime-types';
 import path from 'path';
 import { toString } from 'putil-varhelpers';
 import vary from 'vary';
-import { HttpStatusCode } from '@opra/common';
 const charsetRegExp = /;\s*charset\s*=/;
 export class HttpOutgoingHost {
     attachment(filename) {
@@ -160,7 +160,7 @@ export class HttpOutgoingHost {
         if (req?.fresh)
             this.statusCode = 304;
         // strip irrelevant headers
-        if (204 === this.statusCode || 304 === this.statusCode) {
+        if (this.statusCode === 204 || this.statusCode === 304) {
             this.removeHeader('Content-Type');
             this.removeHeader('Content-Length');
             this.removeHeader('Transfer-Encoding');

package/esm/http/impl/multipart-reader.js

@@ -1,57 +1,155 @@
+import { randomFillSync } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import nodePath from 'node:path';
+import typeIs from '@browsery/type-is';
+import { BadRequestError } from '@opra/common';
+import busboy from 'busboy';
 import { EventEmitter } from 'events';
-import formidable from 'formidable';
-import fs from 'fs/promises';
+import fsPromise from 'fs/promises';
+import { isNotNullish } from 'valgen';
 export class MultipartReader extends EventEmitter {
-    constructor(incoming, options) {
+    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._incoming = incoming;
-        const form = (this._form = formidable({
-            ...options,
-            filter: (part) => {
-                return !this._cancelled && (!options?.filter || options.filter(part));
-            },
-        }));
-        form.once('error', () => {
+        this.tempDirectory = options?.tempDirectory || os.tmpdir();
+        const { request } = context;
+        const form = busboy({ headers: request.headers });
+        this._form = form;
+        form.once('error', (e) => {
             this._cancelled = true;
+            this._finished = true;
             if (this.listenerCount('error') > 0)
-                this.emit('error');
+                this.emit('error', e);
         });
-        form.on('field', (fieldName, value) => {
-            const item = { fieldName, type: 'field', value };
+        form.on('close', () => {
+            this._finished = true;
+        });
+        form.on('field', (field, value, info) => {
+            const item = {
+                kind: 'field',
+                field,
+                value,
+                mimeType: info.mimeType,
+                encoding: info.encoding,
+            };
             this._items.push(item);
             this._stack.push(item);
             this.emit('field', item);
             this.emit('item', item);
         });
-        form.on('file', (fieldName, file) => {
-            const item = { fieldName, type: 'file', file };
-            this._items.push(item);
-            this._stack.push(item);
-            this.emit('file', item);
-            this.emit('item', item);
+        form.on('file', (field, file, info) => {
+            const saveTo = nodePath.join(this.tempDirectory, `opra-${generateFileName()}`);
+            file.pipe(fs.createWriteStream(saveTo));
+            file.once('end', () => {
+                const item = {
+                    kind: 'file',
+                    field,
+                    storedPath: saveTo,
+                    filename: info.filename,
+                    mimeType: info.mimeType,
+                    encoding: info.encoding,
+                };
+                this._items.push(item);
+                this._stack.push(item);
+                this.emit('file', item);
+                this.emit('item', item);
+            });
         });
     }
     get items() {
         return this._items;
     }
-    getNext() {
-        if (!this._form.ended)
+    async getNext() {
+        let item = this._stack.shift();
+        if (!item && !this._finished) {
             this.resume();
-        return new Promise((resolve, reject) => {
-            if (this._stack.length)
-                return resolve(this._stack.shift());
-            if (this._form.ended)
-                return resolve(undefined);
-            this.once('item', () => resolve(this._stack.shift()));
-            this.once('error', e => reject(e));
-        });
+            item = await new Promise((resolve, reject) => {
+                let resolved = false;
+                if (this._stack.length)
+                    return resolve(this._stack.shift());
+                if (this._form.ended)
+                    return resolve(undefined);
+                this._form.once('close', () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    resolve(this._stack.shift());
+                });
+                this.once('item', () => {
+                    this.pause();
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    resolve(this._stack.shift());
+                });
+                this.once('error', e => reject(e));
+            });
+        }
+        if (item && this.mediaType) {
+            const field = this.mediaType.findMultipartField(item.field);
+            if (!field)
+                throw new BadRequestError(`Unknown multipart field (${item.field})`);
+            if (item.kind === 'field') {
+                const decode = field.generateCodec('decode', { ignoreReadonlyFields: true, projection: '*' });
+                item.value = decode(item.value, {
+                    onFail: issue => `Multipart field (${item.field}) validation failed: ` + issue.message,
+                });
+            }
+            else if (item.kind === 'file') {
+                if (field.contentType) {
+                    const arr = Array.isArray(field.contentType) ? field.contentType : [field.contentType];
+                    if (!(item.mimeType && arr.find(ct => typeIs.is(item.mimeType, [ct])))) {
+                        throw new BadRequestError(`Multipart field (${item.field}) do not accept this content type`);
+                    }
+                }
+            }
+        }
+        /** if all items received we check for required items */
+        if (this._finished && this.mediaType && this.mediaType.multipartFields?.length > 0) {
+            const fieldsLeft = new Set(this.mediaType.multipartFields);
+            for (const x of this._items) {
+                const field = this.mediaType.findMultipartField(x.field);
+                if (field)
+                    fieldsLeft.delete(field);
+            }
+            let issues;
+            for (const field of fieldsLeft) {
+                if (!field.required)
+                    continue;
+                try {
+                    isNotNullish(null, { onFail: () => `Multi part field "${String(field.fieldName)}" is required` });
+                }
+                catch (e) {
+                    if (!issues) {
+                        issues = e.issues;
+                        this.context.errors.push(e);
+                    }
+                    else
+                        issues.push(...e.issues);
+                }
+            }
+            if (this.context.errors.length)
+                throw this.context.errors[0];
+        }
+        return item;
+    }
+    async getAll() {
+        const items = [...this._items];
+        let item;
+        while (!this._cancelled && (item = await this.getNext())) {
+            items.push(item);
+        }
+        return items;
     }
-    getAll() {
+    getAll_() {
         if (this._form.ended)
             return Promise.resolve([...this._items]);
         this.resume();
@@ -68,33 +166,26 @@ export class MultipartReader extends EventEmitter {
             this.resume();
     }
     resume() {
-        if (!this._started)
-            this._form.parse(this._incoming, () => void 0);
-        if (this._form.req)
-            this._form.resume();
+        if (!this._started) {
+            this._started = true;
+            this.context.request.pipe(this._form);
+        }
+        this.context.request.resume();
     }
     pause() {
-        if (this._form.req)
-            this._form.pause();
+        this.context.request.pause();
     }
-    async deleteTempFiles() {
+    async purge() {
         const promises = [];
         this._items.forEach(item => {
-            if (!item.file)
+            if (item.kind !== 'file')
                 return;
-            const file = item.file;
-            promises.push(new Promise(resolve => {
-                if (file._writeStream.closed)
-                    return resolve();
-                file._writeStream.once('close', resolve);
-            })
-                .then(() => {
-                return fs.unlink(file.filepath);
-            })
-                .then(() => {
-                return 0;
-            }));
+            promises.push(fsPromise.unlink(item.storedPath));
         });
         return Promise.allSettled(promises);
     }
 }
+function generateFileName() {
+    const buf = Buffer.alloc(10);
+    return new Date().toISOString().substring(0, 10).replace(/-/g, '') + randomFillSync(buf).toString('hex');
+}

package/esm/http/impl/node-incoming-message.host.js

@@ -1,5 +1,5 @@
-import { Duplex, Readable } from 'stream';
 import { isAsyncIterable, isIterable } from '@opra/common';
+import { Duplex, Readable } from 'stream';
 import { convertToHeaders, convertToHeadersDistinct } from '../utils/convert-to-headers.js';
 import { convertToRawHeaders } from '../utils/convert-to-raw-headers.js';
 export const CRLF = Buffer.from('\r\n');
@@ -33,10 +33,12 @@ export class NodeIncomingMessageHost extends Duplex {
                 else
                     this.body = Buffer.from(JSON.stringify(init.body), 'utf-8');
             }
-            if (init.headers)
+            if (init.headers) {
                 this.rawHeaders = Array.isArray(init.headers) ? init.headers : convertToRawHeaders(init.headers);
-            if (init.trailers)
+            }
+            if (init.trailers) {
                 this.rawTrailers = Array.isArray(init.trailers) ? init.trailers : convertToRawHeaders(init.trailers);
+            }
             this.ip = init.ip || '';
             this.ips = init.ips || (this.ip ? [this.ip] : []);
             if (this.body && !this.headers['content-length'])

package/esm/http/interfaces/node-incoming-message.interface.js

@@ -1,6 +1,6 @@
-import { Readable } from 'stream';
 import { HTTPParser } from '@browsery/http-parser';
 import { isAsyncIterable, isIterable } from '@opra/common';
+import { Readable } from 'stream';
 import { CRLF, kHttpParser, NodeIncomingMessageHost } from '../impl/node-incoming-message.host.js';
 import { concatReadable } from '../utils/concat-readable.js';
 /**
@@ -14,8 +14,9 @@ export var NodeIncomingMessage;
      * @param iterable
      */
     function from(iterable) {
-        if (typeof iterable === 'object' && !(isIterable(iterable) || isAsyncIterable(iterable)))
+        if (typeof iterable === 'object' && !(isIterable(iterable) || isAsyncIterable(iterable))) {
             return new NodeIncomingMessageHost(iterable);
+        }
         const msg = new NodeIncomingMessageHost();
         const parser = (msg[kHttpParser] = new HTTPParser(HTTPParser.REQUEST));
         let bodyChunks;

package/esm/http/utils/body-reader.js

@@ -1,3 +1,5 @@
+import typeIs from '@browsery/type-is';
+import { BadRequestError, InternalServerError, OpraHttpError } from '@opra/common';
 import { Base64Decode } from 'base64-stream';
 import byteParser from 'bytes';
 import { parse as parseContentType } from 'content-type';
@@ -5,8 +7,6 @@ import { EventEmitter } from 'events';
 import iconv from 'iconv-lite';
 import { Writable } from 'stream';
 import * as zlib from 'zlib';
-import typeIs from '@browsery/type-is';
-import { BadRequestError, InternalServerError, OpraHttpError } from '@opra/common';
 /**
  *
  * @class BodyReader
@@ -29,11 +29,12 @@ export class BodyReader extends EventEmitter {
     }
     async read() {
         /* istanbul ignore next */
-        if (this._completed)
+        if (this._completed) {
             throw new InternalServerError({
                 message: 'Stream already read',
                 code: 'STREAM_ALREADY_READ',
             });
+        }
         if (!this.req.readable) {
             throw new InternalServerError({
                 message: 'Stream is not readable',
@@ -57,8 +58,9 @@ export class BodyReader extends EventEmitter {
              * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
              */
             const contentLength = parseInt(this.req.headers['content-length'] || '0', 10);
-            if (this.req.headers['transfer-encoding'] === undefined && !(contentLength && !isNaN(contentLength)))
+            if (this.req.headers['transfer-encoding'] === undefined && !(contentLength && !isNaN(contentLength))) {
                 return this.onEnd();
+            }
             // check the length and limit options.
             // note: we intentionally leave the stream paused,
             // so users should handle the stream themselves.
@@ -143,7 +145,6 @@ export class BodyReader extends EventEmitter {
             message: 'request aborted',
             code: 'ECONNABORTED',
             details: {
-                length,
                 received: this._receivedSize,
             },
         }));

package/esm/http/utils/common.js

@@ -55,6 +55,7 @@ export const validateHeaderValue = hideStackFrames((name, value) => {
     }
 });
 export function validateString(value, name) {
-    if (typeof value !== 'string')
+    if (typeof value !== 'string') {
         throw new TypeError(`Invalid ${name ? name + ' ' : ''}argument. Value must be a string`);
+    }
 }

package/esm/index.js

@@ -6,20 +6,20 @@ import * as HttpOutgoingHost_ from './http/impl/http-outgoing.host.js';
 import * as NodeIncomingMessageHost_ from './http/impl/node-incoming-message.host.js';
 import * as NodeOutgoingMessageHost_ from './http/impl/node-outgoing-message.host.js';
 export * from './execution-context.js';
-export * from './platform-adapter.js';
-export * from './type-guards.js';
-export * from './helpers/logger.js';
 export * from './helpers/service-base.js';
 export * from './http/express-adapter.js';
 export * from './http/http-adapter.js';
 export * from './http/http-context.js';
+export * from './http/http-handler.js';
+export * from './http/impl/multipart-reader.js';
 export * from './http/interfaces/http-incoming.interface.js';
 export * from './http/interfaces/http-outgoing.interface.js';
 export * from './http/interfaces/node-incoming-message.interface.js';
 export * from './http/interfaces/node-outgoing-message.interface.js';
-export * from './http/impl/multipart-reader.js';
 export * from './http/utils/wrap-exception.js';
 export * from './interfaces/logger.interface.js';
+export * from './platform-adapter.js';
+export * from './type-guards.js';
 export var classes;
 (function (classes) {
     classes.HttpIncomingHost = HttpIncomingHost_.HttpIncomingHost;

package/esm/platform-adapter.js

@@ -1,8 +1,7 @@
 import './augmentation/18n.augmentation.js';
-import { AsyncEventEmitter } from 'strict-typed-events';
 import { I18n } from '@opra/common';
+import { AsyncEventEmitter } from 'strict-typed-events';
 import { kAssetCache } from './constants.js';
-import { Logger } from './helpers/logger.js';
 import { AssetCache } from './http/impl/asset-cache.js';
 /**
  * @class PlatformAdapter
@@ -12,8 +11,6 @@ export class PlatformAdapter extends AsyncEventEmitter {
         super();
         this[kAssetCache] = new AssetCache();
         this.document = document;
-        this.logger =
-            options?.logger && options.logger instanceof Logger ? options.logger : new Logger({ instance: options?.logger });
         this.i18n = options?.i18n || I18n.defaultInstance;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.31",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -15,14 +15,15 @@
     "build": "npm run build:cjs && npm run build:esm",
     "build:cjs": "tsc -b tsconfig-build-cjs.json",
     "build:esm": "tsc -b tsconfig-build-esm.json",
-    "postbuild": "npm run _copyi18n && npm run _copy_pkg_files",
-    "_copy_pkg_files": "cp README.md package.json ../../LICENSE ../../build/core && cp ../../package.cjs.json ../../build/core/cjs/package.json",
-    "_copyi18n": "cp -R i18n ../../build/core/i18n",
+    "postbuild": "npm run postbuild:copy_1 && npm run postbuild:copy_2",
+    "postbuild:copy_1": "cp README.md package.json ../../LICENSE ../../build/core && cp ../../package.cjs.json ../../build/core/cjs/package.json",
+    "postbuild:copy_2": "cp -R i18n ../../build/core/i18n",
     "lint": "eslint . --max-warnings=0",
-    "check": "madge --circular src/**",
+    "lint:fix": "eslint . --max-warnings=0 --fix",
     "format": "prettier . --write --log-level=warn",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
+    "check": "madge --circular src/**",
+    "test": "jest --passWithNoTests",
+    "cover": "jest --passWithNoTests --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all",
     "clean:test": "ts-cleanup -s test --all",
@@ -30,11 +31,12 @@
     "clean:cover": "rimraf ../../coverage/client"
   },
   "dependencies": {
+    "@browsery/http-parser": "^0.5.8",
     "@browsery/type-is": "^1.6.18-r2",
-    "@opra/common": "^1.0.0-alpha.3",
-    "@types/formidable": "^3.4.5",
+    "@opra/common": "^1.0.0-alpha.31",
     "accepts": "^1.3.8",
     "base64-stream": "^1.0.0",
+    "busboy": "^1.6.0",
     "bytes": "^3.1.2",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
@@ -42,15 +44,18 @@
     "cookie-signature": "^1.2.1",
     "cppzst": "^2.0.12",
     "encodeurl": "^2.0.0",
-    "formidable": "^3.5.1",
     "fresh": "^0.5.2",
+    "iconv-lite": "^0.6.3",
     "mime-types": "^2.1.35",
-    "power-tasks": "^1.7.3",
+    "power-tasks": "^1.7.7",
     "putil-isplainobject": "^1.1.5",
+    "putil-merge": "^3.13.0",
     "putil-varhelpers": "^1.6.5",
     "range-parser": "^1.2.1",
-    "raw-body": "^2.5.2",
-    "strict-typed-events": "^2.3.3",
+    "raw-body": "^3.0.0",
+    "reflect-metadata": "^0.2.2",
+    "strict-typed-events": "^2.4.0",
+    "tslib": "^2.6.3",
     "vary": "^1.1.2"
   },
   "optionalDependencies": {
@@ -61,6 +66,7 @@
     "@faker-js/faker": "^8.4.1",
     "@types/accepts": "^1.3.7",
     "@types/base64-stream": "^1.0.5",
+    "@types/busboy": "^1.5.4",
     "@types/bytes": "^3.1.4",
     "@types/content-disposition": "^0.5.8",
     "@types/content-type": "^1.1.8",
@@ -76,8 +82,9 @@
     "cookie-parser": "^1.4.6",
     "crypto-browserify": "^3.12.0",
     "express": "^4.19.2",
-    "fastify": "^4.28.0",
+    "fastify": "^4.28.1",
     "path-browserify": "^1.0.1",
+    "supertest": "^7.0.0",
     "ts-gems": "^3.4.0"
   },
   "type": "module",

package/types/augmentation/18n.augmentation.d.ts

@@ -1,4 +1,3 @@
-import { FallbackLng, LanguageResource } from '@opra/common';
 declare module '@opra/common' {
     interface I18n {
         loadResourceDir(dirnames: string | string[], deep?: boolean, overwrite?: boolean): Promise<void>;
@@ -35,3 +34,4 @@ declare module '@opra/common' {
         }
     }
 }
+export {};

package/types/constants.d.ts

@@ -1,2 +1 @@
-export declare const kHandler: unique symbol;
 export declare const kAssetCache: unique symbol;

package/types/execution-context.d.ts

@@ -1,5 +1,5 @@
+import { ApiDocument, OpraHttpError, OpraSchema } from '@opra/common';
 import { AsyncEventEmitter } from 'strict-typed-events';
-import { ApiDocument, OpraSchema } from '@opra/common';
 /**
  * @namespace ExecutionContext
  */
@@ -8,7 +8,6 @@ export declare namespace ExecutionContext {
         document: ApiDocument;
         protocol: OpraSchema.Protocol;
         platform: string;
-        platformArgs: any;
     }
     type OnFinishListener = (error: Error | undefined, context: ExecutionContext) => void | Promise<void>;
 }
@@ -19,7 +18,7 @@ export declare abstract class ExecutionContext extends AsyncEventEmitter {
     readonly document: ApiDocument;
     readonly protocol: OpraSchema.Protocol;
     readonly platform: string;
-    readonly platformArgs: any;
+    errors: OpraHttpError[];
     protected constructor(init: ExecutionContext.Initiator);
     addListener(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
     removeListener(event: 'finish', listener: ExecutionContext.OnFinishListener): this;

package/types/http/express-adapter.d.ts

@@ -1,5 +1,5 @@
-import { Application } from 'express';
 import { ApiDocument, HttpController } from '@opra/common';
+import { Application } from 'express';
 import { HttpAdapter } from './http-adapter.js';
 export declare class ExpressAdapter extends HttpAdapter {
     readonly app: Application;

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

@@ -1,27 +1,54 @@
 import { ApiDocument, HttpApi, OpraSchema } from '@opra/common';
-import { kHandler } from '../constants.js';
 import { PlatformAdapter } from '../platform-adapter.js';
 import { HttpContext } from './http-context.js';
-import { HttpHandler } from './impl/http-handler.js';
+import { HttpHandler } from './http-handler.js';
 export declare namespace HttpAdapter {
+    type NextCallback = () => Promise<void>;
     /**
-     * @type Interceptor
+     * @type InterceptorFunction
      */
-    type Interceptor = (context: HttpContext, next: () => Promise<void>) => Promise<void>;
+    type InterceptorFunction = IHttpInterceptor['intercept'];
+    /**
+     * @interface IHttpInterceptor
+     */
+    type IHttpInterceptor = {
+        intercept(context: HttpContext, next: NextCallback): Promise<void>;
+    };
     interface Options extends PlatformAdapter.Options {
         basePath?: string;
-        interceptors?: HttpAdapter.Interceptor[];
-        onRequest?: (ctx: HttpContext) => void | Promise<void>;
+        interceptors?: (InterceptorFunction | IHttpInterceptor)[];
     }
+    type EventFunction = (context: HttpContext) => void | Promise<void>;
+    interface Events {
+        createContext: EventFunction;
+        error: EventFunction;
+        request: EventFunction;
+    }
+}
+export interface HttpAdapter {
+    addListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    on<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    once<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    removeListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    off<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this;
+    prependListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+    prependOnceListener<Event extends keyof HttpAdapter.Events>(event: Event, listener: HttpAdapter.Events[Event]): this;
+    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
 }
 /**
  *
  * @class HttpAdapter
  */
 export declare abstract class HttpAdapter extends PlatformAdapter {
-    protected [kHandler]: HttpHandler;
+    readonly handler: HttpHandler;
     readonly protocol: OpraSchema.Protocol;
-    interceptors: HttpAdapter.Interceptor[];
+    interceptors: (HttpAdapter.InterceptorFunction | HttpAdapter.IHttpInterceptor)[];
     protected constructor(document: ApiDocument, options?: HttpAdapter.Options);
     get api(): HttpApi;
 }

package/types/http/http-context.d.ts

@@ -2,8 +2,8 @@ import { HttpController, HttpMediaType, HttpOperation, OpraSchema } from '@opra/
 import { ExecutionContext } from '../execution-context.js';
 import type { HttpAdapter } from './http-adapter';
 import { MultipartReader } from './impl/multipart-reader.js';
-import type { HttpIncoming } from './interfaces/http-incoming.interface';
-import type { HttpOutgoing } from './interfaces/http-outgoing.interface';
+import type { HttpIncoming } from './interfaces/http-incoming.interface.js';
+import type { HttpOutgoing } from './interfaces/http-outgoing.interface.js';
 export declare namespace HttpContext {
     interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'protocol'> {
         adapter: HttpAdapter;
@@ -26,9 +26,9 @@ export declare class HttpContext extends ExecutionContext {
     protected _multipartReader?: MultipartReader;
     readonly protocol: OpraSchema.Protocol;
     readonly adapter: HttpAdapter;
-    readonly controller: HttpController;
+    readonly controller?: HttpController;
     readonly controllerInstance?: any;
-    readonly operation: HttpOperation;
+    readonly operation?: HttpOperation;
     readonly operationHandler?: Function;
     readonly request: HttpIncoming;
     readonly response: HttpOutgoing;