@opra/core 0.18.4 → 0.20.0

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

@@ -1,8 +1,9 @@
-import { HttpRequestMessage, HttpResponseMessage } from '@opra/common';
 import { OpraAdapter } from '../adapter.js';
 import { ILogger } from '../interfaces/logger.interface.js';
 import { Request } from '../interfaces/request.interface.js';
 import { RequestContext } from '../interfaces/request-context.interface.js';
+import { HttpRequestMessage } from './http-request-message.js';
+import { HttpResponseMessage } from './http-response-message.js';
 /**
  * @namespace OpraHttpAdapter
  */

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

@@ -0,0 +1,122 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as stream from 'stream';
+import { HeaderInfo, ParserType } from '@browsery/http-parser';
+import { HttpHeaders } from '@opra/common';
+declare const kHeaders: unique symbol;
+declare const kHeadersProxy: unique symbol;
+declare const kTrailers: unique symbol;
+declare const kTrailersProxy: unique symbol;
+declare const kOnHeaderReceived: unique symbol;
+declare const kOnTrailersReceived: unique symbol;
+declare const kOnBodyChunk: unique symbol;
+declare const kOnReadComplete: unique symbol;
+export interface HttpMessage {
+    httpVersion?: string;
+    httpVersionMajor?: number;
+    httpVersionMinor?: number;
+    headers?: any;
+    trailers?: any;
+    rawHeaders?: string[];
+    rawTrailers?: string[];
+    body?: any;
+    complete?: boolean;
+    upgrade?: boolean;
+    end(body?: any): this;
+    send(body: any): this;
+}
+export declare namespace HttpMessage {
+    interface Initiator {
+        httpVersionMajor?: number;
+        httpVersionMinor?: number;
+        headers?: HttpHeaders.Initiator;
+        trailers?: HttpHeaders.Initiator;
+        rawHeaders?: string[];
+        rawTrailers?: string[];
+        body?: any;
+    }
+}
+export interface HttpMessageHost extends stream.Duplex {
+}
+export declare abstract class HttpMessageHost implements HttpMessage {
+    static kHeaders: symbol;
+    static kHeadersProxy: symbol;
+    static kTrailers: symbol;
+    static kTrailersProxy: symbol;
+    static kOnHeaderReceived: symbol;
+    static kOnTrailersReceived: symbol;
+    static kOnBodyChunk: symbol;
+    static kOnReadComplete: symbol;
+    protected [kHeaders]: HttpHeaders;
+    protected [kHeadersProxy]: any;
+    protected [kTrailers]: HttpHeaders;
+    protected [kTrailersProxy]: any;
+    protected _bodyChunks?: Buffer[];
+    protected _rawHeaders?: string[];
+    protected _rawTrailers?: string[];
+    protected _headersChanged?: boolean;
+    protected _trailersChanged?: boolean;
+    httpVersionMajor?: number;
+    httpVersionMinor?: number;
+    shouldKeepAlive?: boolean;
+    complete: boolean;
+    upgrade?: boolean;
+    body?: Buffer | ArrayBuffer;
+    protected constructor();
+    get httpVersion(): string | undefined;
+    set httpVersion(value: string | undefined);
+    get headers(): any;
+    set headers(headers: any);
+    get trailers(): any;
+    set trailers(trailers: any);
+    get rawHeaders(): string[];
+    set rawHeaders(headers: string[]);
+    get rawTrailers(): string[];
+    set rawTrailers(trailers: string[]);
+    getHeader(name: 'set-cookie' | 'Set-Cookie'): string[] | undefined;
+    getHeader(name: string): string | undefined;
+    get(name: 'set-cookie' | 'Set-Cookie'): string[] | undefined;
+    get(name: string): string | undefined;
+    /**
+     * Set header `field` to `val`,
+     * or pass an object of header fields.
+     *
+     * Examples:
+     *
+     *    msg.setHeader('Foo', ['bar', 'baz']);
+     *    msg.setHeader('Accept', 'application/json');
+     *    msg.setHeader({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+     *
+     * @public
+     */
+    setHeader(name: 'set-cookie' | 'Set-Cookie', value: string | string[]): this;
+    setHeader(name: string, value: number | string | string[]): this;
+    setHeader(headers: HttpHeaders.Initiator): this;
+    /**
+     * Set header `field` to `val`,
+     * or pass an object of header fields.
+     * Alias as msg.setHeader()
+     * @public
+     */
+    set(name: 'set-cookie' | 'Set-Cookie', value: string | string[]): this;
+    set(name: string, value: number | string | string[]): this;
+    set(headers: Record<string, number | string | string[]>): this;
+    getHeaders(): Record<string, string>;
+    getHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    send(body: any): this;
+    end(body?: any): this;
+    setTimeout(): this;
+    protected _init(args: HttpMessage.Initiator): void;
+    protected _parseBuffer(buf: Buffer | ArrayBuffer, parserType: ParserType): void;
+    protected _initHeaders(): void;
+    protected _initTrailers(): void;
+    protected _buildRawHeaders(): void;
+    protected _buildRawTrailers(): void;
+    protected [kOnHeaderReceived](info: HeaderInfo): void;
+    protected [kOnTrailersReceived](trailers: string[]): void;
+    protected [kOnBodyChunk](chunk: Buffer, offset: number, length: number): void;
+    protected [kOnReadComplete](): void;
+}
+export {};

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

@@ -0,0 +1,213 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'http';
+import { Readable } from 'stream';
+import { HttpMessage } from './http-message.host.js';
+export interface HttpRequestMessage extends HttpMessage {
+    /**
+     * In case of server request, the HTTP version sent by the client. In the case of
+     * client response, the HTTP version of the connected-to server.
+     * Probably either `'1.1'` or `'1.0'`.
+     *
+     * Also `message.httpVersionMajor` is the first integer and`message.httpVersionMinor` is the second.
+     * @since v0.1.1
+     */
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    /**
+     * The request/response headers object.
+     *
+     * Key-value pairs of header names and values. Header names are lower-cased.
+     */
+    readonly headers: IncomingHttpHeaders;
+    /**
+     * The raw request/response headers list exactly as they were received.
+     */
+    rawHeaders: string[];
+    /**
+     * The request/response trailers object.
+     */
+    readonly trailers: NodeJS.Dict<string>;
+    /**
+     * The raw request/response trailer keys and values exactly as they were received.
+     */
+    rawTrailers: string[];
+    readonly complete: boolean;
+    readonly upgrade?: any;
+    /**
+     * Return the protocol string "http" or "https"
+     * when requested with TLS. When the "trust proxy"
+     * setting is enabled the "X-Forwarded-Proto" header
+     * field will be trusted. If you're running behind
+     * a reverse proxy that supplies https for you this
+     * may be enabled.
+     */
+    protocol: string;
+    /**
+     * Short-hand for:
+     *
+     *    req.protocol == 'https'
+     */
+    secure: boolean;
+    /**
+     * Return the remote address, or when
+     * "trust proxy" is `true` return
+     * the upstream addr.
+     */
+    ip: string;
+    /**
+     * When "trust proxy" is `true`, parse
+     * the "X-Forwarded-For" ip address list.
+     *
+     * For example if the value were "client, proxy1, proxy2"
+     * you would receive the array `["client", "proxy1", "proxy2"]`
+     * where "proxy2" is the furthest down-stream.
+     */
+    ips: string[];
+    /**
+     * Parse the "Host" header field hostname.
+     */
+    hostname: string;
+    method: string;
+    url: string;
+    baseUrl: string;
+    query: Record<string, any>;
+    /**
+     * Return request header.
+     *
+     * The `Referrer` header field is special-cased,
+     * both `Referrer` and `Referer` are interchangeable.
+     *
+     * Examples:
+     *
+     *     req.get('Content-Type');
+     *     // => "text/plain"
+     *
+     *     req.get('content-type');
+     *     // => "text/plain"
+     *
+     *     req.get('Something');
+     *     // => undefined
+     *
+     * Aliased as `req.header()`.
+     */
+    get(name: 'set-cookie'): string[] | undefined;
+    get(name: string): string | undefined;
+    header(name: 'set-cookie'): string[] | undefined;
+    header(name: string): string | undefined;
+    /**
+     * Check if the given `type(s)` is acceptable, returning
+     * the best match when true, otherwise `undefined`, in which
+     * case you should respond with 406 "Not Acceptable".
+     *
+     * The `type` value may be a single mime type string
+     * such as "application/json", the extension name
+     * such as "json", a comma-delimted list such as "json, html, text/plain",
+     * or an array `["json", "html", "text/plain"]`. When a list
+     * or array is given the _best_ match, if any is returned.
+     *
+     * Examples:
+     *
+     *     // Accept: text/html
+     *     req.accepts('html');
+     *     // => "html"
+     *
+     *     // Accept: text/*, application/json
+     *     req.accepts('html');
+     *     // => "html"
+     *     req.accepts('text/html');
+     *     // => "text/html"
+     *     req.accepts('json, text');
+     *     // => "json"
+     *     req.accepts('application/json');
+     *     // => "application/json"
+     *
+     *     // Accept: text/*, application/json
+     *     req.accepts('image/png');
+     *     req.accepts('png');
+     *     // => undefined
+     *
+     *     // Accept: text/*;q=.5, application/json
+     *     req.accepts(['html', 'json']);
+     *     req.accepts('html, json');
+     *     // => "json"
+     */
+    accepts(): string[];
+    accepts(type: string): string | false;
+    accepts(type: string[]): string | false;
+    accepts(...type: string[]): string | false;
+    /**
+     * Returns the first accepted charset of the specified character sets,
+     * based on the request's Accept-Charset HTTP header field.
+     * If none of the specified charsets is accepted, returns false.
+     *
+     * For more information, or if you have issues or concerns, see accepts.
+     */
+    acceptsCharsets(): string[];
+    acceptsCharsets(charset: string): string | false;
+    acceptsCharsets(charset: string[]): string | false;
+    acceptsCharsets(...charset: string[]): string | false;
+    /**
+     * Returns the first accepted encoding of the specified encodings,
+     * based on the request's Accept-Encoding HTTP header field.
+     * If none of the specified encodings is accepted, returns false.
+     *
+     * For more information, or if you have issues or concerns, see accepts.
+     */
+    acceptsEncodings(): string[];
+    acceptsEncodings(encoding: string): string | false;
+    acceptsEncodings(encoding: string[]): string | false;
+    acceptsEncodings(...encoding: string[]): string | false;
+    /**
+     * Returns the first accepted language of the specified languages,
+     * based on the request's Accept-Language HTTP header field.
+     * If none of the specified languages is accepted, returns false.
+     *
+     * For more information, or if you have issues or concerns, see accepts.
+     */
+    acceptsLanguages(): string[];
+    acceptsLanguages(lang: string): string | false;
+    acceptsLanguages(lang: string[]): string | false;
+    acceptsLanguages(...lang: string[]): string | false;
+    /**
+     * Check if the incoming request contains the "Content-Type"
+     * header field, and it contains the give mime `type`.
+     *
+     * Examples:
+     *
+     *      // With Content-Type: text/html; charset=utf-8
+     *      req.is('html');
+     *      req.is('text/html');
+     *      req.is('text/*');
+     *      // => true
+     *
+     *      // When Content-Type is application/json
+     *      req.is('json');
+     *      req.is('application/json');
+     *      req.is('application/*');
+     *      // => true
+     *
+     *      req.is('html');
+     *      // => false
+     */
+    is(type: string | string[]): string | false | null;
+    is(...types: string[]): string | false | null;
+}
+export declare namespace HttpRequestMessage {
+    interface Initiator extends HttpMessage.Initiator {
+        httpVersionMajor?: number;
+        httpVersionMinor?: number;
+        method: string;
+        url: string;
+        protocol?: string;
+        baseUrl?: string;
+        ip?: string;
+        ips?: [];
+    }
+    function create(init: Initiator): HttpRequestMessage;
+    function fromBuffer(buffer: Buffer | ArrayBuffer): HttpRequestMessage;
+    function fromStream(readable: Readable): Promise<HttpRequestMessage>;
+}

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

@@ -1,5 +1,5 @@
-import { HttpRequestMessage } from '@opra/common';
 import { RequestHost } from '../request.host.js';
+import { HttpRequestMessage } from './http-request-message.js';
 export declare class HttpRequestHost extends RequestHost {
     protected _incoming: HttpRequestMessage;
     constructor(init: RequestHost.Initiator, _incoming: HttpRequestMessage);

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

@@ -0,0 +1,321 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import cookie from 'cookie';
+import { Readable } from 'stream';
+import { HttpMessage, HttpMessageHost } from './http-message.host.js';
+import type { HttpRequestMessage } from './http-request-message.js';
+export interface CookieOptions extends cookie.CookieSerializeOptions {
+    signed?: boolean;
+}
+export interface HttpResponseMessage extends HttpMessage {
+    method?: string | undefined;
+    url?: string | undefined;
+    body?: any;
+    statusCode?: number;
+    statusMessage?: string;
+    readonly upgrade?: any;
+    /**
+     * Return request header.
+     *
+     * The `Referrer` header field is special-cased,
+     * both `Referrer` and `Referer` are interchangeable.
+     *
+     * Examples:
+     *
+     *     req.get('Content-Type');
+     *     // => "text/plain"
+     *
+     *     req.get('content-type');
+     *     // => "text/plain"
+     *
+     *     req.get('Something');
+     *     // => undefined
+     *
+     * Aliased as `req.header()`.
+     */
+    get(field: string): string | undefined;
+    getHeader(name: string): number | string | string[] | undefined;
+    /**
+     * Set header `field` to `val`,
+     * or pass an object of header fields.
+     *
+     * Examples:
+     *
+     *    msg.setHeader('Foo', ['bar', 'baz']);
+     *    msg.setHeader('Accept', 'application/json');
+     *    msg.setHeader({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+     *
+     */
+    setHeader(name: string, value: number | string | readonly string[]): this;
+    /**
+     * Set status `code`.
+     */
+    status(code: number): this;
+    /**
+     * Set the response HTTP status code to `statusCode` and send its string representation as the response body.
+     * @link http://expressjs.com/4x/api.html#res.sendStatus
+     *
+     * Examples:
+     *
+     *    res.sendStatus(200); // equivalent to res.status(200).send('OK')
+     *    res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
+     *    res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
+     *    res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
+     */
+    sendStatus(code: number): this;
+    /**
+     * Set Link header field with the given `links`.
+     *
+     * Examples:
+     *
+     *    res.links({
+     *      next: 'http://api.example.com/users?page=2',
+     *      last: 'http://api.example.com/users?page=5'
+     *    });
+     */
+    links(links: any): this;
+    /**
+     * Send JSON response.
+     *
+     * Examples:
+     *
+     *     res.json(null);
+     *     res.json({ user: 'tj' });
+     *     res.status(500).json('oh noes!');
+     *     res.status(404).json('I dont have that');
+     */
+    json(body: any): this;
+    /**
+     * Set _Content-Type_ response header with `type` through `mime.lookup()`
+     * when it does not contain "/", or set the Content-Type to `type` otherwise.
+     *
+     * Examples:
+     *
+     *     res.type('.html');
+     *     res.type('html');
+     *     res.type('json');
+     *     res.type('application/json');
+     *     res.type('png');
+     */
+    contentType(type: string): this;
+    /**
+     * Set _Content-Type_ response header with `type` through `mime.lookup()`
+     * when it does not contain "/", or set the Content-Type to `type` otherwise.
+     *
+     * Examples:
+     *
+     *     res.type('.html');
+     *     res.type('html');
+     *     res.type('json');
+     *     res.type('application/json');
+     *     res.type('png');
+     */
+    type(type: string): this;
+    /**
+     * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
+     */
+    attachment(filename?: string): this;
+    /**
+     * Set header `field` to `val`, or pass
+     * an object of header fields.
+     *
+     * Examples:
+     *
+     *    res.set('Foo', ['bar', 'baz']);
+     *    res.set('Accept', 'application/json');
+     *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+     *
+     * Aliased as `res.header()`.
+     */
+    set(field: any): this;
+    set(field: string, value?: string | string[]): this;
+    header(field: any): this;
+    header(field: string, value?: string | string[]): this;
+    append(field: string, value?: string | string[]): this;
+    /** Clear cookie `name`. */
+    clearCookie(name: string, options?: CookieOptions): this;
+    /**
+     * Set cookie `name` to `val`, with the given `options`.
+     *
+     * Options:
+     *
+     *    - `maxAge`   max-age in milliseconds, converted to `expires`
+     *    - `signed`   sign the cookie
+     *    - `path`     defaults to "/"
+     *
+     * Examples:
+     *
+     *    // "Remember Me" for 15 minutes
+     *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+     *
+     *    // save as above
+     *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+     */
+    cookie(name: string, val: string, options: CookieOptions): this;
+    cookie(name: string, val: any, options: CookieOptions): this;
+    cookie(name: string, val: any): this;
+    /**
+     * Set the location header to `url`.
+     *
+     * The given `url` can also be the name of a mapped url, for
+     * example by default express supports "back" which redirects
+     * to the _Referrer_ or _Referer_ headers or "/".
+     *
+     * Examples:
+     *
+     *    res.location('/foo/bar').;
+     *    res.location('http://example.com');
+     *    res.location('../login'); // /blog/post/1 -> /blog/login
+     *
+     * Mounting:
+     *
+     *   When an application is mounted and `res.location()`
+     *   is given a path that does _not_ lead with "/" it becomes
+     *   relative to the mount-point. For example if the application
+     *   is mounted at "/blog", the following would become "/blog/login".
+     *
+     *      res.location('login');
+     *
+     *   While the leading slash would result in a location of "/login":
+     *
+     *      res.location('/login');
+     */
+    location(url: string): this;
+    /**
+     * Redirect to the given `url` with optional response `status`
+     * defaulting to 302.
+     *
+     * The resulting `url` is determined by `res.location()`, so
+     * it will play nicely with mounted apps, relative paths,
+     * `"back"` etc.
+     *
+     * Examples:
+     *
+     *    res.redirect('back');
+     *    res.redirect('/foo/bar');
+     *    res.redirect('http://example.com');
+     *    res.redirect(301, 'http://example.com');
+     *    res.redirect('http://example.com', 301);
+     *    res.redirect('../login'); // /blog/post/1 -> /blog/login
+     */
+    redirect(url: string): void;
+    redirect(status: number, url: string): void;
+    /** @deprecated use res.redirect(status, url) instead */
+    redirect(url: string, status: number): void;
+}
+/**
+ * @namespace HttpResponseMessage
+ */
+export declare namespace HttpResponseMessage {
+    interface Initiator extends HttpMessage.Initiator {
+        statusCode?: number;
+        statusMessage?: string;
+        req?: HttpRequestMessage;
+        chunkedEncoding?: boolean;
+    }
+    function create(init: Initiator): HttpResponseMessage;
+    function fromBuffer(buffer: Buffer | ArrayBuffer): HttpResponseMessage;
+    function fromStream(readable: Readable): Promise<HttpResponseMessage>;
+}
+/**
+ * @class HttpResponseMessageHost
+ */
+export declare class HttpResponseMessageHost extends HttpMessageHost implements HttpResponseMessage {
+    chunkedEncoding?: boolean;
+    req?: HttpRequestMessage;
+    statusCode?: number;
+    statusMessage?: string;
+    constructor();
+    header(name: 'set-cookie' | 'Set-Cookie', value: string | string[]): this;
+    header(name: string, value: number | string): this;
+    header(headers: Record<string, number | string | string[]>): this;
+    append(name: string, value: string | string[]): this;
+    /**
+     * Set "Content-Disposition" header to "attachment" with optional `filename`.
+     */
+    attachment(filename?: string): this;
+    /**
+     * Alias for msg.type()
+     */
+    contentType(type: string): this;
+    /**
+     * Set _Content-Type_ response header with `type` through `mime.lookup()`
+     * when it does not contain "/", or set the Content-Type to `type` otherwise.
+     *
+     * Examples:
+     *
+     *     res.type('.html');
+     *     res.type('html');
+     *     res.type('json');
+     *     res.type('application/json');
+     *     res.type('png');
+     */
+    type(type: string): this;
+    /**
+     * Set cookie `name` to `value`, with the given `options`.
+     *
+     * Options:
+     *
+     *    - `maxAge`   max-age in milliseconds, converted to `expires`
+     *    - `signed`   sign the cookie
+     *    - `path`     defaults to "/"
+     *
+     * Examples:
+     *
+     *    // "Remember Me" for 15 minutes
+     *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+     *
+     *    // same as above
+     *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+     *
+     */
+    cookie(name: string, value: string, options?: CookieOptions): this;
+    /**
+     * Clear cookie `name`.
+     */
+    clearCookie(name: string, options?: CookieOptions): this;
+    /**
+     * Set Link header field with the given `links`.
+     *
+     * Examples:
+     *
+     *    res.links({
+     *      next: 'http://api.example.com/users?page=2',
+     *      last: 'http://api.example.com/users?page=5'
+     *    });
+     *
+     */
+    links(links: Record<string, string>): this;
+    redirect(url: string): any;
+    redirect(status: number, url: string): any;
+    /**
+     * Send JSON response.
+     *
+     * Examples:
+     *
+     *     res.json(null);
+     *     res.json({ user: 'tj' });
+     */
+    json(obj: any): this;
+    location(url: string): this;
+    /**
+     * Set status `code`.
+     */
+    status(code: number): this;
+    /**
+     * Set the response HTTP status code to `statusCode` and send its string representation as the response body.
+     * @link http://expressjs.com/4x/api.html#res.sendStatus
+     *
+     * Examples:
+     *
+     *    res.sendStatus(200); // equivalent to res.status(200).send('OK')
+     *    res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
+     *    res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
+     *    res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
+     */
+    sendStatus(statusCode: number): this;
+    protected _init(init: HttpResponseMessage.Initiator): void;
+    static create(init: HttpResponseMessage.Initiator): HttpResponseMessage;
+    static fromBuffer(buffer: Buffer | ArrayBuffer): HttpResponseMessage;
+    static fromStream(readable: Readable): Promise<HttpResponseMessage>;
+}

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

@@ -1,5 +1,5 @@
-import { HttpResponseMessage } from '@opra/common';
 import { ResponseHost } from '../response.host.js';
+import { HttpResponseMessage } from './http-response-message.js';
 export declare class HttpResponseHost extends ResponseHost {
     protected _outgoing: HttpResponseMessage;
     constructor(init: ResponseHost.Initiator, _outgoing: HttpResponseMessage);

package/types/adapter/interfaces/request-context.interface.d.ts

@@ -1,4 +1,6 @@
-import { ApiDocument, HttpRequestMessage, HttpResponseMessage } from '@opra/common';
+import { ApiDocument } from '@opra/common';
+import { HttpRequestMessage } from '../http/http-request-message.js';
+import { HttpResponseMessage } from '../http/http-response-message.js';
 import { Request } from './request.interface.js';
 import { Response } from './response.interface.js';
 export declare namespace RequestContext {