@opra/common 0.13.0 → 0.15.0

package/esm/http/http-params.d.ts

@@ -1,48 +1,53 @@
 import { StrictOmit } from 'ts-gems';
-import { ResponsiveMap } from '../helpers/responsive-map.js';
-import { HttpParamCodec } from './http-param-codec.js';
-declare const kEntries: unique symbol;
-declare const kSize: unique symbol;
-declare const kParamDefs: unique symbol;
-declare const kOptions: unique symbol;
-export type HttpParamsInit = string | URLSearchParams | HttpParams | Map<string, any> | Record<string, any>;
-export interface HttpParamsCodec {
-    encodeKey?: (key: string) => string;
-    decodeKey?: (key: string) => string;
-    encodeValue?: (value: any) => string;
-    decodeValue?: (value: string) => any;
+import { ResponsiveMap } from '../helpers/index.js';
+import { BooleanCodec } from './codecs/boolean-codec.js';
+import { DateCodec } from './codecs/date-codec.js';
+import { FilterCodec } from './codecs/filter-codec.js';
+import { IntegerCodec } from './codecs/integer-codec.js';
+import { NumberCodec } from './codecs/number-codec.js';
+import { StringCodec } from './codecs/string-codec.js';
+export declare namespace HttpParams {
+    type Initiator = string | URLSearchParams | HttpParams | Map<string, any> | Record<string, any>;
+    interface Options {
+        onChange?: () => void;
+        params?: Record<string, ParamDefinition>;
+    }
+    type ParamDefinition = StrictOmit<HttpParamMetadata, 'codec'> & {
+        codec?: Codec | string;
+    };
+    interface Codec {
+        decode(value: string): any;
+        encode(value: any): string;
+    }
 }
-interface HttpParamMeta {
-    codec: HttpParamCodec;
+interface HttpParamMetadata {
+    codec: HttpParams.Codec;
     array?: boolean | 'strict';
     arrayDelimiter?: string;
     minArrayItems?: number;
     maxArrayItems?: number;
 }
-export type HttpParamDefinition = StrictOmit<HttpParamMeta, 'codec'> & {
-    codec?: HttpParamCodec | string;
-};
-export interface HttpParamsOptions extends HttpParamsCodec {
-    onChange?: () => void;
-    params?: Record<string, HttpParamDefinition>;
-}
+declare const kEntries: unique symbol;
+declare const kSize: unique symbol;
+declare const kParamDefs: unique symbol;
+declare const kOptions: unique symbol;
 export declare class HttpParams {
     protected static kEntries: symbol;
     protected static kSize: symbol;
     protected static kParamDefs: symbol;
     protected static kOptions: symbol;
-    protected [kEntries]: ResponsiveMap<string, any[]>;
+    protected [kEntries]: ResponsiveMap<any[]>;
     protected [kSize]: number;
-    protected [kOptions]: HttpParamsOptions;
-    protected [kParamDefs]: Map<string, HttpParamMeta>;
-    constructor(init?: HttpParamsInit, options?: HttpParamsOptions);
+    protected [kOptions]: HttpParams.Options;
+    protected [kParamDefs]: Map<string, HttpParamMetadata>;
+    constructor(init?: HttpParams.Initiator, options?: HttpParams.Options);
     get size(): number;
     /**
      * Appends a new value to the existing set of values for a parameter
      * and returns this instance
      */
     append(name: string, value?: any): this;
-    appendAll(input: HttpParamsInit): this;
+    appendAll(input: HttpParams.Initiator): this;
     changed(): void;
     clear(): void;
     /**
@@ -85,9 +90,9 @@ export declare class HttpParams {
      * separated by `&`s.
      */
     toString(): string;
-    define(name: string, options?: HttpParamDefinition): this;
-    encodeKey(key: string): string;
-    decodeKey(key: string): string;
+    getProxy(): Record<string, any>;
+    define(params: Record<string, HttpParams.ParamDefinition>): this;
+    define(name: string, options: HttpParams.ParamDefinition): this;
     encodeValue(value: any, key: string): string;
     decodeValue(value: string, key: string): any;
     protected _append(name: string, value?: any): void;
@@ -95,5 +100,14 @@ export declare class HttpParams {
     protected _set(name: string, value: any, index?: number): void;
     [Symbol.iterator](): IterableIterator<[string, string]>;
     get [Symbol.toStringTag](): string;
+    static codecs: {
+        boolean: BooleanCodec;
+        date: DateCodec;
+        filter: FilterCodec;
+        integer: IntegerCodec;
+        number: NumberCodec;
+        string: StringCodec;
+    };
 }
+export declare function encodeURIParam(v: string): string;
 export {};

package/esm/http/http-params.js

@@ -1,29 +1,16 @@
 var _a, _b, _c;
 import { splitString, tokenize } from 'fast-tokenizer';
-import { ResponsiveMap } from '../helpers/responsive-map.js';
-import { BooleanCodec } from './param-codec/boolean-codec.js';
-import { DateCodec } from './param-codec/date-codec.js';
-import { FilterCodec } from './param-codec/filter-codec.js';
-import { IntegerCodec } from './param-codec/integer-codec.js';
-import { NumberCodec } from './param-codec/number-codec.js';
-import { StringCodec } from './param-codec/string-codec.js';
-import { encodeURIParam } from './utils/encodeURIParam.js';
+import { ResponsiveMap } from '../helpers/index.js';
+import { BooleanCodec } from './codecs/boolean-codec.js';
+import { DateCodec } from './codecs/date-codec.js';
+import { FilterCodec } from './codecs/filter-codec.js';
+import { IntegerCodec } from './codecs/integer-codec.js';
+import { NumberCodec } from './codecs/number-codec.js';
+import { StringCodec } from './codecs/string-codec.js';
 const kEntries = Symbol('kEntries');
 const kSize = Symbol('kSize');
 const kParamDefs = Symbol('kParamDefs');
 const kOptions = Symbol('kOptions');
-const defaultKeyDecoder = (s) => decodeURIComponent(s);
-const defaultValueDecoder = (s) => decodeURIComponent(s);
-const defaultKeyEncoder = (s) => encodeURIParam(s);
-const defaultValueEncoder = (s) => encodeURIParam(s);
-const internalCodecs = {
-    'boolean': new BooleanCodec(),
-    'date': new DateCodec(),
-    'filter': new FilterCodec(),
-    'integer': new IntegerCodec(),
-    'number': new NumberCodec(),
-    'string': new StringCodec()
-};
 export class HttpParams {
     constructor(init, options) {
         this[_a] = new ResponsiveMap();
@@ -64,7 +51,7 @@ export class HttpParams {
                     quotes: true,
                     brackets: true
                 });
-                const k = this.decodeKey(itemTokenizer.next() || '');
+                const k = decodeURIComponent(itemTokenizer.next() || '');
                 const v = this.decodeValue(itemTokenizer.join('='), k);
                 this._append(k, v);
             }
@@ -139,7 +126,7 @@ export class HttpParams {
      * Retrieves value of a given parameter at given index
      */
     get(name, index = 0) {
-        const values = this[kEntries].get(name.toLowerCase());
+        const values = this[kEntries].get(name);
         return values && values.length > index ? values[index] : null;
     }
     /**
@@ -190,46 +177,66 @@ export class HttpParams {
     toString() {
         const out = [];
         this.forEach((v, k) => {
-            out.push(this.encodeKey(k) +
+            out.push(encodeURIParam(k) +
                 (v ? '=' + this.encodeValue(v, k) : ''));
         });
         return out.join('&');
     }
-    define(name, options) {
-        if (!name)
-            throw new Error('Parameter name required');
-        if (typeof options?.codec === 'string' && !internalCodecs[options.codec])
+    getProxy() {
+        const _this = this;
+        return this[kEntries].getProxy({
+            get(target, p, receiver) {
+                if (typeof p === 'string') {
+                    const v = _this[kEntries].get(p);
+                    return v ? (v.length > 1 ? v : v[0]) : undefined;
+                }
+                return Reflect.get(target, p, receiver);
+            },
+            set(target, p, newValue, receiver) {
+                if (typeof p === 'string') {
+                    _this.set(p, newValue);
+                    return true;
+                }
+                return Reflect.set(target, p, newValue, receiver);
+            },
+        });
+    }
+    define(arg0, options) {
+        if (typeof arg0 === 'object') {
+            for (const [name, def] of Object.entries(arg0))
+                this.define(name, def);
+            return this;
+        }
+        if (!arg0)
+            throw new Error('"name" argument required');
+        if (!options)
+            throw new Error('"options" argument required');
+        if (typeof options.codec === 'string' && !HttpParams.codecs[options.codec])
             throw new Error(`Unknown url parameter format name "${options.codec}"`);
         const codec = (typeof options?.codec === 'string'
-            ? internalCodecs[options.codec]
-            : options?.codec) || internalCodecs.string;
+            ? HttpParams.codecs[options.codec]
+            : options?.codec) || HttpParams.codecs.string;
         const meta = {
             ...options,
             codec
         };
-        this[kParamDefs].set(name, meta);
+        this[kParamDefs].set(arg0, meta);
         return this;
     }
-    encodeKey(key) {
-        return (this[kOptions].encodeKey || defaultKeyEncoder)(key);
-    }
-    decodeKey(key) {
-        return (this[kOptions].decodeKey || defaultKeyDecoder)(key);
-    }
     encodeValue(value, key) {
         const prmDef = this[kParamDefs].get(key);
         if (prmDef) {
             const delimReplace = '%' + (prmDef.arrayDelimiter || ',').charCodeAt(0).toString(16).toUpperCase();
-            const fn = (x) => encodeURIParam(prmDef.codec.encode(x)).replaceAll(',', delimReplace);
+            const fn = (x) => encodeURIParam(prmDef.codec.encode(x))
+                .replace(/,/g, delimReplace);
             return Array.isArray(value)
                 ? value.map((v) => fn(v)).join(prmDef.arrayDelimiter || ',')
                 : fn(value);
         }
-        return (this[kOptions].encodeValue || defaultValueEncoder)(value);
+        return encodeURIParam(value);
     }
     decodeValue(value, key) {
         const prmDef = this[kParamDefs].get(key);
-        const valueDecoder = (this[kOptions].decodeValue || defaultValueDecoder);
         let val = value;
         if (prmDef) {
             if (prmDef.array) {
@@ -238,11 +245,11 @@ export class HttpParams {
                     brackets: true,
                     quotes: true,
                     keepQuotes: false
-                }).map((x) => valueDecoder(x));
+                }).map((x) => decodeURIComponent(x));
             }
             else
-                val = valueDecoder(val);
-            const fn = (x) => prmDef.codec.decode(valueDecoder(x));
+                val = decodeURIComponent(val);
+            const fn = (x) => prmDef.codec.decode(decodeURIComponent(x));
             val = Array.isArray(val) ? val.map(fn) : fn(val);
             if (prmDef.array === 'strict')
                 val = Array.isArray(val) ? val : [val];
@@ -256,7 +263,7 @@ export class HttpParams {
             }
             return val;
         }
-        return valueDecoder(value);
+        return decodeURIComponent(value);
     }
     _append(name, value) {
         let values = this[kEntries].get(name);
@@ -315,3 +322,28 @@ HttpParams.kEntries = kEntries;
 HttpParams.kSize = kSize;
 HttpParams.kParamDefs = kParamDefs;
 HttpParams.kOptions = kOptions;
+HttpParams.codecs = {
+    'boolean': new BooleanCodec(),
+    'date': new DateCodec(),
+    'filter': new FilterCodec(),
+    'integer': new IntegerCodec(),
+    'number': new NumberCodec(),
+    'string': new StringCodec()
+};
+/**
+ * Encode input string with standard encodeURIComponent and then un-encode specific characters.
+ */
+const ENCODING_REGEX = /%(\d[a-f0-9])/gi;
+const ENCODING_REPLACEMENTS = {
+    '2C': ',',
+    '2F': '/',
+    '24': '$',
+    '3A': ':',
+    '3B': ';',
+    '3D': '=',
+    '3F': '?',
+    '40': '@'
+};
+export function encodeURIParam(v) {
+    return encodeURIComponent(v).replace(ENCODING_REGEX, (s, t) => ENCODING_REPLACEMENTS[t] ?? s);
+}

package/esm/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/esm/http/http-request-message.js

@@ -0,0 +1,148 @@
+import accepts from 'accepts';
+import { HTTPParser } from 'http-parser-js';
+import typeIs from 'type-is';
+import { HttpMessageHost } from './http-message.host.js';
+import { HttpParams } from './http-params.js';
+const HTTP_VERSION_PATTERN = /^(\d)\.(\d)$/;
+export var HttpRequestMessage;
+(function (HttpRequestMessage) {
+    function create(init) {
+        return HttpRequestMessageHost.create(init);
+    }
+    HttpRequestMessage.create = create;
+    function fromBuffer(buffer) {
+        return HttpRequestMessageHost.fromBuffer(buffer);
+    }
+    HttpRequestMessage.fromBuffer = fromBuffer;
+    async function fromStream(readable) {
+        return HttpRequestMessageHost.fromStream(readable);
+    }
+    HttpRequestMessage.fromStream = fromStream;
+})(HttpRequestMessage || (HttpRequestMessage = {}));
+const kQuery = Symbol('kQuery');
+const kQueryProxy = Symbol('kQueryProxy');
+const kProtocol = Symbol('kProtocol');
+/**
+ *
+ */
+class HttpRequestMessageHost extends HttpMessageHost {
+    constructor() {
+        super();
+        this.httpVersionMajor = 1;
+        this.httpVersionMinor = 0;
+        this[kQuery] = new HttpParams();
+        this[kQueryProxy] = this[kQuery].getProxy();
+    }
+    get httpVersion() {
+        return this.httpVersionMajor + '.' + this.httpVersionMinor;
+    }
+    set httpVersion(value) {
+        const m = HTTP_VERSION_PATTERN.exec(value);
+        if (!m)
+            throw new TypeError(`Invalid http version string (${value})`);
+        this.httpVersionMajor = parseInt(m[1], 10);
+        this.httpVersionMinor = parseInt(m[2], 10);
+    }
+    get hostname() {
+        let host = this.get('X-Forwarded-Host') || this.get('Host');
+        if (host && host.indexOf(',') !== -1) {
+            // Note: X-Forwarded-Host is normally only ever a single value, but this is to be safe.
+            host = host.substring(0, host.indexOf(',')).trimEnd();
+        }
+        if (!host)
+            return '';
+        // IPv6 literal support
+        const offset = host[0] === '['
+            ? host.indexOf(']') + 1
+            : 0;
+        const index = host.indexOf(':', offset);
+        return index !== -1
+            ? host.substring(0, index)
+            : host;
+    }
+    get protocol() {
+        if (this[kProtocol])
+            return this[kProtocol];
+        // Note: X-Forwarded-Proto is normally only ever a
+        //       single value, but this is to be safe.
+        const header = this.get('X-Forwarded-Proto');
+        if (header) {
+            const index = header.indexOf(',');
+            return index !== -1
+                ? header.substring(0, index).trim()
+                : header.trim();
+        }
+        return 'http';
+    }
+    set protocol(v) {
+        this[kProtocol] = v;
+    }
+    get secure() {
+        return this.protocol === 'https';
+    }
+    get query() {
+        return this[kQueryProxy];
+    }
+    set query(value) {
+        this[kQuery].clear();
+        this[kQuery].appendAll(value);
+    }
+    header(name) {
+        return this.getHeader(name);
+    }
+    accepts(...type) {
+        const accept = accepts(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.types.apply(accept, type);
+    }
+    acceptsCharsets(...charset) {
+        const accept = accepts(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.charsets.apply(accept, charset);
+    }
+    acceptsEncodings(...encoding) {
+        const accept = accepts(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.encodings.apply(accept, encoding);
+    }
+    acceptsLanguages(...lang) {
+        const accept = accepts(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.languages.apply(accept, lang);
+    }
+    is(type, ...otherTypes) {
+        const types = Array.isArray(type) ? type : [type];
+        if (otherTypes.length)
+            types.push(...otherTypes);
+        const contentType = this.getHeader('content-type');
+        return contentType ? typeIs.is(contentType, types) : null;
+    }
+    _init(init) {
+        super._init(init);
+        this.method = init.method.toUpperCase();
+        this.url = init.url;
+        this.baseUrl = init.baseUrl || this.url;
+        this.protocol = init.protocol;
+    }
+    [HttpMessageHost.kOnHeaderReceived](info) {
+        super[HttpMessageHost.kOnHeaderReceived](info);
+        this.method = HTTPParser.methods[info.method];
+        this.url = info.url;
+        this.baseUrl = info.url;
+    }
+    static create(init) {
+        const msg = new HttpRequestMessageHost();
+        msg._init(init);
+        return msg;
+    }
+    static fromBuffer(buffer) {
+        const msg = new HttpRequestMessageHost();
+        msg._parseBuffer(buffer, HTTPParser.REQUEST);
+        return msg;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static async fromStream(readable) {
+        throw new Error('fromStream is not implemented yet');
+    }
+}
+HttpRequestMessageHost.kQuery = kQuery;