@opra/core 0.33.13 → 1.0.0-alpha.10

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

@@ -0,0 +1,27 @@
+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';
+export declare namespace HttpAdapter {
+    /**
+     * @type Interceptor
+     */
+    type Interceptor = (context: HttpContext, next: () => Promise<void>) => Promise<void>;
+    interface Options extends PlatformAdapter.Options {
+        basePath?: string;
+        interceptors?: HttpAdapter.Interceptor[];
+        onRequest?: (ctx: HttpContext) => void | Promise<void>;
+    }
+}
+/**
+ *
+ * @class HttpAdapter
+ */
+export declare abstract class HttpAdapter extends PlatformAdapter {
+    protected [kHandler]: HttpHandler;
+    readonly protocol: OpraSchema.Protocol;
+    interceptors: HttpAdapter.Interceptor[];
+    protected constructor(document: ApiDocument, options?: HttpAdapter.Options);
+    get api(): HttpApi;
+}

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

@@ -0,0 +1,44 @@
+import { HttpController, HttpMediaType, HttpOperation, OpraSchema } from '@opra/common';
+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';
+export declare namespace HttpContext {
+    interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'protocol'> {
+        adapter: HttpAdapter;
+        request: HttpIncoming;
+        response: HttpOutgoing;
+        controller?: HttpController;
+        controllerInstance?: any;
+        operation?: HttpOperation;
+        operationHandler?: Function;
+        cookies?: Record<string, any>;
+        headers?: Record<string, any>;
+        pathParams?: Record<string, any>;
+        queryParams?: Record<string, any>;
+        mediaType?: HttpMediaType;
+        body?: any;
+    }
+}
+export declare class HttpContext extends ExecutionContext {
+    protected _body?: any;
+    protected _multipartReader?: MultipartReader;
+    readonly protocol: OpraSchema.Protocol;
+    readonly adapter: HttpAdapter;
+    readonly controller: HttpController;
+    readonly controllerInstance?: any;
+    readonly operation: HttpOperation;
+    readonly operationHandler?: Function;
+    readonly request: HttpIncoming;
+    readonly response: HttpOutgoing;
+    readonly mediaType?: HttpMediaType;
+    readonly cookies: Record<string, any>;
+    readonly headers: Record<string, any>;
+    readonly pathParams: Record<string, any>;
+    readonly queryParams: Record<string, any>;
+    constructor(init: HttpContext.Initiator);
+    get isMultipart(): boolean;
+    getMultipartReader(): Promise<MultipartReader>;
+    getBody<T>(): Promise<T>;
+}

package/types/http/impl/asset-cache.d.ts

@@ -0,0 +1,5 @@
+export declare class AssetCache {
+    protected _items: WeakMap<any, Record<string, any>>;
+    get<T>(obj: any, name: string): T | undefined;
+    set(obj: any, name: string, asset: any): void;
+}

package/types/http/impl/http-handler.d.ts

@@ -0,0 +1,73 @@
+import { HttpOperationResponse } from '@opra/common';
+import { kAssetCache } from '../../constants.js';
+import type { HttpAdapter } from '../http-adapter.js';
+import { HttpContext } from '../http-context.js';
+import { HttpOutgoing } from '../interfaces/http-outgoing.interface.js';
+import { AssetCache } from './asset-cache.js';
+/**
+ * @namespace
+ */
+export declare namespace HttpHandler {
+    /**
+     * @interface ResponseArgs
+     */
+    interface ResponseArgs {
+        statusCode: number;
+        contentType?: string;
+        operationResponse?: HttpOperationResponse;
+        body?: any;
+    }
+}
+/**
+ * @class HttpHandler
+ */
+export declare class HttpHandler {
+    readonly adapter: HttpAdapter;
+    protected [kAssetCache]: AssetCache;
+    constructor(adapter: HttpAdapter);
+    /**
+     * Main http request handler
+     * @param context
+     * @protected
+     */
+    handleRequest(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     */
+    parseRequest(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _parseParameters(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _parseContentType(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _executeRequest(context: HttpContext): Promise<any>;
+    /**
+     *
+     * @param context
+     * @param responseValue
+     * @protected
+     */
+    protected _sendResponse(context: HttpContext, responseValue: any): Promise<void>;
+    /**
+     *
+     * @param context
+     * @param body
+     * @protected
+     */
+    protected _determineResponseArgs(context: HttpContext, body: any): HttpHandler.ResponseArgs;
+    sendDocumentSchema(context: HttpContext): Promise<void>;
+    sendErrorResponse(response: HttpOutgoing, errors: any[]): Promise<void>;
+}

package/types/http/impl/http-incoming.host.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import parseRange from 'range-parser';
+import type { HttpIncoming } from '../interfaces/http-incoming.interface';
+import { BodyReader } from '../utils/body-reader.js';
+export interface HttpIncomingHost extends HttpIncoming {
+}
+export declare class HttpIncomingHost implements HttpIncoming {
+    body?: any;
+    get protocol(): string;
+    get secure(): boolean;
+    get hostname(): string | undefined;
+    get fresh(): boolean;
+    get xhr(): boolean;
+    header(name: string): any;
+    get(name: string): any;
+    accepts(...types: any): any;
+    acceptsCharsets(...charsets: any): any;
+    acceptsEncodings(...encoding: any): any;
+    acceptsLanguages(...lang: any): any;
+    is(type: string | string[], ...otherTypes: string[]): string | false | null;
+    range(size: number, options: any): parseRange.Ranges | parseRange.Result | undefined;
+    readBody(options: BodyReader.Options): Promise<string | Buffer | undefined>;
+}

package/types/http/impl/http-outgoing.host.d.ts

@@ -0,0 +1,17 @@
+import type { CookieOptions, HttpOutgoing } from '../interfaces/http-outgoing.interface';
+export interface HttpOutgoingHost extends HttpOutgoing {
+}
+export declare class HttpOutgoingHost {
+    attachment(filename?: string): this;
+    contentType(type: any): this;
+    setHeader(field: string | Record<string, any>, val?: any): this;
+    clearCookie(name: string, options: CookieOptions): this;
+    cookie(name: string, value: any, options?: CookieOptions): this;
+    status(code: number): this;
+    sendStatus(statusCode: number): this;
+    links(links: Record<string, string>): this;
+    location(url: string): this;
+    redirect(arg0: string | number, arg1?: string): void;
+    send(body: any): this;
+    vary(field: string): this;
+}

package/types/http/{helpers/multipart-helper.d.ts → impl/multipart-reader.d.ts}

@@ -2,25 +2,27 @@
 import { EventEmitter } from 'events';
 import formidable from 'formidable';
 import type IncomingForm from 'formidable/Formidable.js';
-import { HttpIncomingMessage } from '../impl/http-incoming-message.host.js';
+import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface.js';
 export type MultipartFile = formidable.File;
 export type MultipartItem = {
-    field: string;
+    fieldName: string;
+    type: 'field' | 'file';
     value?: string;
     file?: MultipartFile;
 };
-export declare class MultipartIterator extends EventEmitter {
+export declare class MultipartReader extends EventEmitter {
+    protected _incoming: NodeIncomingMessage;
+    protected _started: boolean;
     protected _cancelled: boolean;
     protected _form: IncomingForm;
     protected _items: MultipartItem[];
     protected _stack: MultipartItem[];
-    protected constructor(options?: formidable.Options);
+    constructor(incoming: NodeIncomingMessage, options?: formidable.Options);
     get items(): MultipartItem[];
     getNext(): Promise<MultipartItem | undefined>;
     getAll(): Promise<MultipartItem[]>;
     cancel(): void;
     resume(): void;
     pause(): void;
-    deleteFiles(): Promise<PromiseSettledResult<any>[]>;
-    static create(incoming: HttpIncomingMessage, options?: formidable.Options): Promise<MultipartIterator>;
+    deleteTempFiles(): Promise<PromiseSettledResult<any>[]>;
 }

package/types/http/impl/{http-incoming-message.host.d.ts → node-incoming-message.host.d.ts}

@@ -2,39 +2,26 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import http, { IncomingHttpHeaders } from 'http';
-import { Duplex, Readable } from 'stream';
 import { HTTPParserJS } from '@browsery/http-parser';
+import { IncomingHttpHeaders } from 'http';
+import { Duplex, Readable } from 'stream';
+import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface';
 export declare const CRLF: Buffer;
 export declare const kHeaders: unique symbol;
 export declare const kHeadersDistinct: unique symbol;
 export declare const kTrailers: unique symbol;
 export declare const kTrailersDistinct: unique symbol;
-export interface HttpIncomingMessage extends Pick<http.IncomingMessage, 'httpVersion' | 'httpVersionMajor' | 'httpVersionMinor' | 'complete' | 'headers' | 'trailers' | 'rawHeaders' | 'rawTrailers' | 'method' | 'url'>, Readable {
-}
-export declare namespace HttpIncomingMessageHost {
-    interface Initiator {
-        httpVersionMajor?: number;
-        httpVersionMinor?: number;
-        method?: string;
-        url?: string;
-        headers?: Record<string, any> | string[];
-        trailers?: Record<string, any> | string[];
-        body?: any;
-        ip?: string;
-        ips?: string[];
-    }
-}
+export declare const kHttpParser: unique symbol;
 /**
  *
- * @class HttpIncomingMessageHost
+ * @class NodeIncomingMessageHost
  */
-export declare class HttpIncomingMessageHost extends Duplex implements HttpIncomingMessage {
+export declare class NodeIncomingMessageHost extends Duplex implements NodeIncomingMessage {
     protected [kHeaders]?: IncomingHttpHeaders;
     protected [kHeadersDistinct]?: NodeJS.Dict<string[]>;
     protected [kTrailers]?: NodeJS.Dict<string>;
     protected [kTrailersDistinct]?: NodeJS.Dict<string[]>;
-    protected _httpParser: HTTPParserJS | undefined;
+    protected [kHttpParser]: HTTPParserJS | undefined;
     protected _readStream?: Readable;
     httpVersionMajor: number;
     httpVersionMinor: number;
@@ -42,12 +29,14 @@ export declare class HttpIncomingMessageHost extends Duplex implements HttpIncom
     url: string;
     rawHeaders: string[];
     rawTrailers: string[];
+    params?: Record<string, any>;
+    cookies?: Record<string, any>;
     body?: Buffer;
     complete: boolean;
     ip?: string;
     ips?: string[];
     joinDuplicateHeaders: boolean;
-    constructor(init?: HttpIncomingMessageHost.Initiator);
+    constructor(init?: NodeIncomingMessage.Initiator);
     get httpVersion(): string;
     get headers(): IncomingHttpHeaders;
     set headers(headers: IncomingHttpHeaders);
@@ -57,6 +46,4 @@ export declare class HttpIncomingMessageHost extends Duplex implements HttpIncom
     get trailersDistinct(): NodeJS.Dict<string[]>;
     _read(size: number): void;
     _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    static from(iterable: string | Iterable<any> | AsyncIterable<any> | HttpIncomingMessageHost.Initiator): HttpIncomingMessageHost;
-    static fromAsync(iterable: string | Iterable<any> | AsyncIterable<any> | HttpIncomingMessageHost.Initiator): Promise<HttpIncomingMessageHost>;
 }

package/types/http/impl/{http-outgoing-message.host.d.ts → node-outgoing-message.host.d.ts}

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import http, { OutgoingHttpHeaders } from 'http';
-import { Duplex, Writable } from 'stream';
-import type { HttpIncomingMessage } from './http-incoming-message.host.js';
+import { OutgoingHttpHeaders } from 'http';
+import { Duplex } from 'stream';
+import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface';
+import type { NodeOutgoingMessage } from '../interfaces/node-outgoing-message.interface';
 export declare const kOutHeaders: unique symbol;
 export declare const kOutTrailers: unique symbol;
 declare global {
@@ -12,57 +13,40 @@ declare global {
         entries(): IterableIterator<[string, any]>;
     }
 }
-export interface HttpOutgoingMessage extends Pick<http.ServerResponse, 'addTrailers' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'removeHeader' | 'hasHeader' | 'headersSent' | 'statusCode' | 'statusMessage' | 'sendDate'>, Writable {
-    req?: HttpIncomingMessage;
-    appendHeader(name: string, value: string | readonly string[]): this;
-    setHeader(name: string, value: number | string | readonly string[]): this;
-}
-export declare namespace HttpOutgoingMessageHost {
-    interface Initiator {
-        req?: HttpIncomingMessage;
-        statusCode?: number;
-        statusMessage?: string;
-        headers?: OutgoingHttpHeaders | Headers | Map<string, any> | string[];
-        chunkedEncoding?: boolean;
-        sendDate?: boolean;
-        strictContentLength?: boolean;
-        body?: string | Iterable<any> | AsyncIterable<any> | Object;
-    }
-}
 /**
  *
- * @class HttpOutgoingMessageHost
+ * @class NodeOutgoingMessageHost
  */
-export declare class HttpOutgoingMessageHost extends Duplex implements HttpOutgoingMessage {
+export declare class NodeOutgoingMessageHost extends Duplex implements NodeOutgoingMessage {
     protected [kOutHeaders]: Record<string, any>;
     protected [kOutTrailers]: Record<string, any>;
     protected _headersSent: boolean;
     protected _httpVersionMajor?: number;
     protected _httpVersionMinor?: number;
     finished: boolean;
-    req?: HttpIncomingMessage;
+    req: NodeIncomingMessage;
     statusCode: number;
     statusMessage: string;
     chunkedEncoding: boolean;
     sendDate: boolean;
     strictContentLength: boolean;
     body?: any;
-    constructor(init?: HttpOutgoingMessageHost.Initiator);
+    constructor(init?: NodeOutgoingMessage.Initiator);
     get httpVersionMajor(): number | undefined;
     get httpVersionMinor(): number | undefined;
     get headersSent(): boolean;
     appendHeader(name: string, value: number | string | readonly string[]): this;
     addTrailers(headers: OutgoingHttpHeaders | [string, string][] | readonly [string, string][]): void;
-    setHeader(name: any, value: any): this;
+    flushHeaders(): void;
+    setHeader(name: string, value: number | string | readonly string[]): this;
     setHeaders(headers: Headers | Map<string, any> | Record<string, any>): this;
     getHeader(name: string): any;
     getHeaderNames(): string[];
-    getRawHeaderNames(): any[];
+    getRawHeaderNames(): string[];
     getHeaders(): OutgoingHttpHeaders;
     hasHeader(name: string): boolean;
     removeHeader(name: string): void;
     end(cb?: () => void): this;
     end(chunk: any, cb?: () => void): this;
     end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
-    static from(init: HttpOutgoingMessageHost.Initiator): HttpOutgoingMessageHost;
 }

package/types/http/{http-server-request.d.ts → interfaces/http-incoming.interface.d.ts}

@@ -1,17 +1,15 @@
+/// <reference types="node" />
 import { Options as RangeParserOptions, Ranges as RangeParserRanges, Result as RangeParserResult } from 'range-parser';
-import { OpraURL } from '@opra/common';
-import type { HttpServerResponse } from './http-server-response';
-import { HttpIncomingMessage, HttpIncomingMessageHost } from './impl/http-incoming-message.host.js';
-export declare namespace HttpServerRequest {
-    function from(instance: HttpIncomingMessage | HttpIncomingMessageHost.Initiator | string | Iterable<any> | AsyncIterable<any>): HttpServerRequest;
-}
-export interface HttpServerRequest extends HttpIncomingMessage {
-    res: HttpServerResponse;
+import { BodyReader } from '../utils/body-reader.js';
+import type { HttpOutgoing } from './http-outgoing.interface';
+import { NodeIncomingMessage } from './node-incoming-message.interface.js';
+/**
+ * @interface HttpIncoming
+ */
+export interface HttpIncoming extends NodeIncomingMessage {
+    res: HttpOutgoing;
     baseUrl: string;
     originalUrl: string;
-    parsedUrl: OpraURL;
-    searchParams: URLSearchParams;
-    body?: any;
     /**
      * Return the protocol string "http" or "https"
      * When the "X-Forwarded-Proto" header field will be trusted
@@ -38,6 +36,10 @@ export interface HttpServerRequest extends HttpIncomingMessage {
      *    req.protocol === 'https'
      */
     secure: boolean;
+    /**
+     * Used for signed cookies
+     */
+    secret?: string;
     /**
      * Parse the "Host" header field to a hostname.
      *
@@ -52,15 +54,13 @@ export interface HttpServerRequest extends HttpIncomingMessage {
      */
     fresh: boolean;
     /**
-     * Check if the request was an _XMLHttpRequest_.
-     *
+     * Path parameter values
      */
-    xhr: boolean;
+    params: Record<string, any>;
     /**
-     * Secret value for cookie encryption
-     *
+     * Cookie parameter values
      */
-    secret?: string;
+    cookies?: Record<string, any>;
     /**
      * Return request header.
      *
@@ -179,4 +179,15 @@ export interface HttpServerRequest extends HttpIncomingMessage {
      * Parse Range header field, capping to the given `size`.
      */
     range(size: number, options?: RangeParserOptions): RangeParserRanges | RangeParserResult | undefined;
+    /**
+     * Receives the body
+     * @param options
+     */
+    readBody(options: BodyReader.Options): Promise<string | Buffer | undefined>;
+}
+/**
+ * @namespace HttpIncoming
+ */
+export declare namespace HttpIncoming {
+    function from(instance: HttpIncoming | NodeIncomingMessage.Initiator | string | Iterable<any> | AsyncIterable<any>): HttpIncoming;
 }

package/types/http/{http-server-response.d.ts → interfaces/http-outgoing.interface.d.ts}

@@ -1,14 +1,15 @@
-import type { HttpServerRequest } from './http-server-request.js';
-import { HttpOutgoingMessage, HttpOutgoingMessageHost } from './impl/http-outgoing-message.host.js';
-export declare namespace HttpServerResponse {
-    function from(instance?: HttpOutgoingMessage | HttpOutgoingMessageHost.Initiator): HttpServerResponse;
-}
-export interface HttpServerResponse extends HttpOutgoingMessage {
-    req?: HttpServerRequest;
+import { StrictOmit } from 'ts-gems';
+import type { HttpIncoming } from './http-incoming.interface';
+import { NodeOutgoingMessage } from './node-outgoing-message.interface.js';
+export interface HttpOutgoing extends StrictOmit<NodeOutgoingMessage, 'req' | 'appendHeader' | 'setHeader'> {
+    req: HttpIncoming;
+    readonly finished?: boolean;
+    appendHeader(name: string, value: string | readonly string[]): this;
+    setHeader(name: string, value: number | string | readonly string[]): this;
     /**
      * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
      */
-    attachment(this: HttpServerResponse, filename?: string): this;
+    attachment(filename?: string): this;
     /** Clear cookie `name`. */
     clearCookie(name: string, options?: CookieOptions): this;
     /**
@@ -111,7 +112,7 @@ export interface HttpServerResponse extends HttpOutgoingMessage {
      * response to the standard description from node's http.STATUS_CODES
      * or the statusCode number if no description.
      */
-    sendStatus(statusCode: number): any;
+    sendStatus(statusCode: number): this;
     /**
      * Send a response.
      *
@@ -132,6 +133,12 @@ export interface CookieOptions {
     path?: string;
     domain?: string;
     secure?: boolean;
-    encode?: ((val: string) => string);
+    encode?: (val: string) => string;
     sameSite?: boolean | 'lax' | 'strict' | 'none';
 }
+/**
+ * @namespace HttpIncoming
+ */
+export declare namespace HttpOutgoing {
+    function from(instance: HttpOutgoing | NodeOutgoingMessage.Initiator): HttpOutgoing;
+}

package/types/http/interfaces/node-incoming-message.interface.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import { Readable } from 'stream';
+/**
+ * @interface NodeIncomingMessage
+ */
+export interface NodeIncomingMessage extends Readable, Pick<http.IncomingMessage, 'httpVersion' | 'httpVersionMajor' | 'httpVersionMinor' | 'complete' | 'headers' | 'trailers' | 'rawHeaders' | 'rawTrailers' | 'method' | 'url'> {
+}
+/**
+ *
+ * @namespace NodeIncomingMessage
+ */
+export declare namespace NodeIncomingMessage {
+    interface Initiator {
+        httpVersionMajor?: number;
+        httpVersionMinor?: number;
+        method?: string;
+        url?: string;
+        headers?: Record<string, any> | string[];
+        trailers?: Record<string, any> | string[];
+        params?: Record<string, any>;
+        cookies?: Record<string, any>;
+        body?: any;
+        ip?: string;
+        ips?: string[];
+    }
+    /**
+     * Creates a new NodeIncomingMessage from given argument
+     * @param iterable
+     */
+    function from(iterable: string | Iterable<any> | AsyncIterable<any> | Initiator): NodeIncomingMessage;
+    /**
+     * Creates a new NodeIncomingMessage from given argument
+     * @param iterable
+     */
+    function fromAsync(iterable: string | Iterable<any> | AsyncIterable<any> | Initiator): Promise<NodeIncomingMessage>;
+}

package/types/http/interfaces/node-outgoing-message.interface.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http, { OutgoingHttpHeaders } from 'http';
+import { Writable } from 'stream';
+import { NodeIncomingMessage } from './node-incoming-message.interface.js';
+export interface NodeOutgoingMessage extends Writable, Pick<http.ServerResponse, 'addTrailers' | 'getHeader' | 'getHeaders' | 'getHeaderNames' | 'flushHeaders' | 'removeHeader' | 'hasHeader' | 'headersSent' | 'statusCode' | 'statusMessage' | 'sendDate'> {
+    req: NodeIncomingMessage;
+    getRawHeaderNames(): string[];
+    appendHeader(name: string, value: string | readonly string[]): this;
+    setHeader(name: string, value: number | string | readonly string[]): this;
+}
+/**
+ *
+ * @namespace NodeOutgoingMessage
+ */
+export declare namespace NodeOutgoingMessage {
+    interface Initiator {
+        req: NodeIncomingMessage;
+        statusCode?: number;
+        statusMessage?: string;
+        headers?: OutgoingHttpHeaders | Headers | Map<string, any> | string[];
+        chunkedEncoding?: boolean;
+        sendDate?: boolean;
+        strictContentLength?: boolean;
+        body?: string | Iterable<any> | AsyncIterable<any> | Object;
+        parsedUrl?: URL;
+    }
+    function from(init: Initiator): NodeOutgoingMessage;
+}

package/types/http/utils/body-reader.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import nodeStream from 'node:stream';
+import { EventEmitter } from 'events';
+import type { HttpIncoming } from '../interfaces/http-incoming.interface.js';
+/**
+ *
+ * @namespace BodyReader
+ */
+export declare namespace BodyReader {
+    interface Options {
+        limit?: number | string;
+    }
+}
+type Callback = (...args: any[]) => any;
+/**
+ *
+ * @class BodyReader
+ */
+export declare class BodyReader extends EventEmitter {
+    readonly req: HttpIncoming;
+    limit?: number;
+    protected _stream: nodeStream.Readable;
+    protected _buffer?: string | Buffer[];
+    protected _completed?: boolean | undefined;
+    protected _receivedSize: number;
+    protected cleanup: Callback;
+    protected onAborted: Callback;
+    protected onData: Callback;
+    protected onEnd: Callback;
+    constructor(req: HttpIncoming, options?: BodyReader.Options);
+    read(): Promise<string | Buffer | undefined>;
+    protected _onEnd(error: any): void;
+    protected _cleanup(): void;
+    protected _onAborted(): void;
+    protected _onData(chunk: Buffer | string): void;
+    static read(req: HttpIncoming, options?: BodyReader.Options): Promise<string | Buffer | undefined>;
+    protected static encoderPipeline(req: HttpIncoming): nodeStream.Readable;
+}
+export {};

package/types/http/utils/wrap-exception.d.ts

@@ -0,0 +1,2 @@
+import { OpraHttpError } from '@opra/common';
+export declare function wrapException(error: any): OpraHttpError;