@opra/core 1.0.0-beta.2 → 1.0.0-beta.4

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

@@ -1,191 +0,0 @@
-/*
-  This file contains code blocks from open source NodeJs project
-  https://github.com/nodejs/
- */
-import { Duplex } from 'stream';
-import { validateHeaderName, validateHeaderValue, validateString } from '../utils/common.js';
-export const kOutHeaders = Symbol.for('kOutHeaders');
-export const kOutTrailers = Symbol.for('kOutTrailers');
-// noinspection JSUnusedLocalSymbols
-/**
- *
- * @class NodeOutgoingMessageHost
- */
-export class NodeOutgoingMessageHost extends Duplex {
-    constructor(init) {
-        super();
-        this._headersSent = false;
-        this.finished = false;
-        if (init) {
-            this.req = init.req;
-            this.statusCode = init?.statusCode || 0;
-            this.statusMessage = init?.statusMessage || '';
-            this.chunkedEncoding = !!init?.chunkedEncoding;
-            this.sendDate = !!init?.sendDate;
-            this.strictContentLength = !!init?.strictContentLength;
-            if (init.headers)
-                this.setHeaders(Array.isArray(init.headers) ? new Map([init.headers]) : init.headers);
-            this.body = init.body;
-        }
-    }
-    get httpVersionMajor() {
-        return this.req?.httpVersionMajor || this._httpVersionMajor;
-    }
-    get httpVersionMinor() {
-        return this.req?.httpVersionMinor || this._httpVersionMinor;
-    }
-    get headersSent() {
-        return this._headersSent;
-    }
-    appendHeader(name, value) {
-        if (this.headersSent)
-            throw new Error(`Cannot set headers after they are sent to the client`);
-        validateHeaderName(name);
-        validateHeaderValue(name, value);
-        const field = name.toLowerCase();
-        const headers = this[kOutHeaders];
-        if (headers == null || !headers[field]) {
-            return this.setHeader(name, value);
-        }
-        // Prepare the field for appending, if required
-        if (!Array.isArray(headers[field][1])) {
-            headers[field][1] = [headers[field][1]];
-        }
-        const existingValues = headers[field][1];
-        if (Array.isArray(value)) {
-            for (let i = 0, length = value.length; i < length; i++) {
-                existingValues.push(value[i]);
-            }
-        }
-        else {
-            existingValues.push(value);
-        }
-        return this;
-    }
-    addTrailers(headers) {
-        if (headers && typeof headers === 'object') {
-            const entries = typeof headers.entries === 'function' ? headers.entries() : Object.entries(headers);
-            let trailers = this[kOutTrailers];
-            if (trailers == null)
-                this[kOutTrailers] = trailers = { __proto__: null };
-            for (const [name, value] of entries) {
-                validateHeaderName(name);
-                validateHeaderValue(name, value);
-                trailers[String(name).toLowerCase()] = [String(name), value];
-            }
-            return;
-        }
-        throw new TypeError('Invalid "headers" argument. Value must be an object or raw headers array');
-    }
-    flushHeaders() {
-        // nothing to do
-    }
-    setHeader(name, value) {
-        if (this.headersSent)
-            throw new Error(`Cannot set headers after they are sent to the client`);
-        validateHeaderName(name);
-        validateHeaderValue(name, value);
-        let headers = this[kOutHeaders];
-        if (headers == null)
-            this[kOutHeaders] = headers = { __proto__: null };
-        headers[name.toLowerCase()] = [name, value];
-        return this;
-    }
-    setHeaders(headers) {
-        if (this.headersSent)
-            throw new Error(`Cannot set headers after they are sent to the client`);
-        if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
-            const entries = typeof headers.entries === 'function' ? headers.entries() : Object.entries(headers);
-            for (const entry of entries) {
-                this.setHeader(entry[0], entry[1]);
-            }
-            return this;
-        }
-        throw new TypeError('Invalid "headers" argument. Value must be an instance of "Headers" or "Map"');
-    }
-    getHeader(name) {
-        validateString(name);
-        const headers = this[kOutHeaders];
-        if (headers == null)
-            return;
-        const entry = headers[name.toLowerCase()];
-        return entry && entry[1];
-    }
-    getHeaderNames() {
-        return this[kOutHeaders] != null ? Object.keys(this[kOutHeaders]) : [];
-    }
-    getRawHeaderNames() {
-        const headersMap = this[kOutHeaders];
-        if (!headersMap)
-            return [];
-        const values = Object.values(headersMap);
-        const headers = Array(values.length);
-        for (let i = 0, l = values.length; i < l; i++) {
-            headers[i] = values[i][0];
-        }
-        return headers;
-    }
-    getHeaders() {
-        const headers = this[kOutHeaders];
-        // @ts-ignore
-        const ret = { __proto__: null };
-        if (headers) {
-            const keys = Object.keys(headers);
-            let key;
-            let val;
-            for (let i = 0; i < keys.length; ++i) {
-                key = keys[i];
-                val = headers[key][1];
-                ret[key] = val;
-            }
-        }
-        return ret;
-    }
-    hasHeader(name) {
-        validateString(name);
-        return this[kOutHeaders] != null && !!this[kOutHeaders][name.toLowerCase()];
-    }
-    removeHeader(name) {
-        validateString(name);
-        if (this.headersSent)
-            throw new Error(`Cannot remove headers after they are sent to the client`);
-        const key = name.toLowerCase();
-        // switch (key) {
-        //   case 'connection':
-        //     this._removedConnection = true;
-        //     break;
-        //   case 'content-length':
-        //     this._removedContLen = true;
-        //     break;
-        //   case 'transfer-encoding':
-        //     this._removedTE = true;
-        //     break;
-        //   case 'date':
-        //     this.sendDate = false;
-        //     break;
-        // }
-        if (this[kOutHeaders] != null) {
-            delete this[kOutHeaders][key];
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    end(arg0, arg1, arg2) {
-        // let cb: (() => void) | undefined;
-        // let chunk: any;
-        // let encoding: BufferEncoding | undefined;
-        //
-        // if (typeof arg0 === 'function')
-        //   cb = arg0;
-        // else {
-        //   chunk = arg0;
-        //   if (typeof arg1 === 'function')
-        //     cb = arg1;
-        //   else {
-        //     encoding = arg1;
-        //     cb = arg2;
-        //   }
-        // }
-        //
-        return this;
-    }
-}

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

@@ -1,22 +0,0 @@
-import { mergePrototype } from '@opra/common';
-import { isHttpIncoming, isNodeIncomingMessage } from '../../type-guards.js';
-import { HttpIncomingHost } from '../impl/http-incoming.host.js';
-import { NodeIncomingMessage } from './node-incoming-message.interface.js';
-/**
- * @namespace HttpIncoming
- */
-export var HttpIncoming;
-(function (HttpIncoming) {
-    function from(instance) {
-        if (isHttpIncoming(instance))
-            return instance;
-        if (!isNodeIncomingMessage(instance))
-            instance = NodeIncomingMessage.from(instance);
-        mergePrototype(instance, HttpIncomingHost.prototype);
-        const req = instance;
-        req.baseUrl = req.baseUrl || '';
-        req.params = req.params || {};
-        return req;
-    }
-    HttpIncoming.from = from;
-})(HttpIncoming || (HttpIncoming = {}));

package/esm/http/interfaces/http-outgoing.interface.js

@@ -1,19 +0,0 @@
-import { mergePrototype } from '@opra/common';
-import { isHttpOutgoing, isNodeOutgoingMessage } from '../../type-guards.js';
-import { HttpOutgoingHost } from '../impl/http-outgoing.host.js';
-import { NodeOutgoingMessage } from './node-outgoing-message.interface.js';
-/**
- * @namespace HttpIncoming
- */
-export var HttpOutgoing;
-(function (HttpOutgoing) {
-    function from(instance) {
-        if (isHttpOutgoing(instance))
-            return instance;
-        if (!isNodeOutgoingMessage(instance))
-            instance = NodeOutgoingMessage.from(instance);
-        mergePrototype(instance, HttpOutgoingHost.prototype);
-        return instance;
-    }
-    HttpOutgoing.from = from;
-})(HttpOutgoing || (HttpOutgoing = {}));

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

@@ -1,61 +0,0 @@
-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';
-/**
- *
- * @namespace NodeIncomingMessage
- */
-export var NodeIncomingMessage;
-(function (NodeIncomingMessage) {
-    /**
-     * Creates a new NodeIncomingMessage from given argument
-     * @param iterable
-     */
-    function from(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;
-        parser[HTTPParser.kOnHeadersComplete] = (info) => {
-            msg.httpVersionMajor = info.versionMajor;
-            msg.httpVersionMinor = info.versionMinor;
-            msg.rawHeaders = info.headers;
-            msg.method = HTTPParser.methods[info.method];
-            msg.url = info.url;
-            msg.emit('headers');
-        };
-        parser[HTTPParser.kOnHeaders] = (trailers) => {
-            msg.rawTrailers = trailers;
-        };
-        parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
-            bodyChunks = bodyChunks || [];
-            bodyChunks.push(chunk.subarray(offset, offset + length));
-        };
-        const readable = concatReadable(Readable.from(iterable), Readable.from(CRLF));
-        msg.once('finish', () => {
-            parser.finish();
-            msg.complete = true;
-            if (bodyChunks)
-                msg.body = Buffer.concat(bodyChunks);
-        });
-        readable.pipe(msg);
-        return msg;
-    }
-    NodeIncomingMessage.from = from;
-    /**
-     * Creates a new NodeIncomingMessage from given argument
-     * @param iterable
-     */
-    async function fromAsync(iterable) {
-        return new Promise((resolve, reject) => {
-            const msg = from(iterable);
-            msg.once('finish', () => resolve(msg));
-            msg.once('error', error => reject(error));
-        });
-    }
-    NodeIncomingMessage.fromAsync = fromAsync;
-})(NodeIncomingMessage || (NodeIncomingMessage = {}));

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

@@ -1,12 +0,0 @@
-import { NodeOutgoingMessageHost } from '../impl/node-outgoing-message.host.js';
-/**
- *
- * @namespace NodeOutgoingMessage
- */
-export var NodeOutgoingMessage;
-(function (NodeOutgoingMessage) {
-    function from(init) {
-        return new NodeOutgoingMessageHost(init);
-    }
-    NodeOutgoingMessage.from = from;
-})(NodeOutgoingMessage || (NodeOutgoingMessage = {}));

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

@@ -1,211 +0,0 @@
-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';
-import { EventEmitter } from 'events';
-import iconv from 'iconv-lite';
-import { Writable } from 'stream';
-import * as zlib from 'zlib';
-/**
- *
- * @class BodyReader
- */
-export class BodyReader extends EventEmitter {
-    constructor(req, options) {
-        super();
-        this.req = req;
-        this._completed = false;
-        this._receivedSize = 0;
-        this.onAborted = () => this._onAborted();
-        this.onData = (chunk) => this._onData(chunk);
-        this.onEnd = (err) => this._onEnd(err);
-        this.cleanup = () => this._cleanup();
-        this.limit = options?.limit
-            ? typeof options.limit === 'number'
-                ? options.limit
-                : byteParser(options.limit)
-            : undefined;
-    }
-    async read() {
-        /* istanbul ignore next */
-        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',
-                code: 'STREAM_NOT_READABLE',
-            });
-        }
-        return new Promise((resolve, reject) => {
-            // eslint-disable-next-line prefer-const
-            let sizeStream;
-            this.once('finish', (error, data) => {
-                if (sizeStream)
-                    this.req.unpipe(sizeStream);
-                if (error)
-                    return reject(error);
-                resolve(data);
-            });
-            /**
-             * Check if a request has a request body.
-             * A request with a body __must__ either have `transfer-encoding`
-             * or `content-length` headers set.
-             * 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))) {
-                return this.onEnd();
-            }
-            // check the length and limit options.
-            // note: we intentionally leave the stream paused,
-            // so users should handle the stream themselves.
-            if (this.limit != null && contentLength != null && contentLength > this.limit) {
-                return this.onEnd(new OpraHttpError({
-                    message: 'Content Too Large',
-                    code: 'HTTP.CONTENT_TOO_LARGE',
-                    details: {
-                        length: contentLength,
-                        limit: this.limit,
-                    },
-                }, 413));
-            }
-            // Pipe to a Writable stream to count received bytes
-            const _this = this;
-            sizeStream = new Writable({
-                write(chunk, encoding, callback) {
-                    if (_this._completed)
-                        return;
-                    _this._receivedSize += chunk.length;
-                    if (_this.limit != null && _this._receivedSize > _this.limit) {
-                        callback(new OpraHttpError({
-                            message: 'Content Too Large',
-                            code: 'HTTP.CONTENT_TOO_LARGE',
-                            details: {
-                                limit: _this.limit,
-                                received: _this._receivedSize,
-                            },
-                        }, 413));
-                    }
-                },
-            });
-            this.req.pipe(sizeStream);
-            let stream = BodyReader.encoderPipeline(this.req);
-            const mediaType = parseContentType(this.req.headers['content-type'] || '');
-            let charset = (mediaType.parameters.charset || '').toLowerCase();
-            if (!charset && typeIs.is(mediaType.type, ['json', 'xml', 'txt']))
-                charset = 'utf-8';
-            if (charset) {
-                const newStream = iconv.decodeStream(charset);
-                stream.pipe(newStream);
-                stream = newStream;
-            }
-            this._stream = stream;
-            // attach listeners
-            stream.on('aborted', this.onAborted);
-            stream.on('close', this.cleanup);
-            stream.on('data', this.onData);
-            stream.on('end', this.onEnd);
-            stream.on('error', this.onEnd);
-        });
-    }
-    _onEnd(error) {
-        if (this._completed)
-            return;
-        this._completed = true;
-        if (error) {
-            this._stream?.unpipe();
-            this._stream?.pause();
-        }
-        if (error)
-            this.emit('finish', error);
-        else if (Array.isArray(this._buffer))
-            this.emit('finish', error, Buffer.concat(this._buffer));
-        else
-            this.emit('finish', error, this._buffer);
-        this._cleanup();
-    }
-    _cleanup() {
-        if (this._stream) {
-            this._stream.removeListener('aborted', this.onAborted);
-            this._stream.removeListener('close', this.cleanup);
-            this._stream.removeListener('data', this.onData);
-            this._stream.removeListener('end', this.onEnd);
-            this._stream.removeListener('error', this.onEnd);
-        }
-    }
-    _onAborted() {
-        if (this._completed)
-            return;
-        this.onEnd(new BadRequestError({
-            message: 'request aborted',
-            code: 'ECONNABORTED',
-            details: {
-                received: this._receivedSize,
-            },
-        }));
-    }
-    _onData(chunk) {
-        if (this._completed)
-            return;
-        if (typeof chunk === 'string') {
-            this._buffer = this._buffer || '';
-            this._buffer += chunk;
-        }
-        else {
-            this._buffer = this._buffer || [];
-            this._buffer.push(chunk);
-        }
-    }
-    static async read(req, options) {
-        const bodyReady = new BodyReader(req, options);
-        return bodyReady.read();
-    }
-    static encoderPipeline(req) {
-        const contentEncoding = req.headers['content-encoding'] || 'identity';
-        const contentEncodings = (Array.isArray(contentEncoding) ? contentEncoding : contentEncoding.split(/\s*,\s*/))
-            .map(s => s.toLowerCase())
-            .reverse();
-        return contentEncodings.reduce((prev, encoding) => {
-            switch (encoding) {
-                case 'gzip':
-                case 'x-gzip': {
-                    const newStream = zlib.createGunzip();
-                    prev.pipe(newStream);
-                    return newStream;
-                }
-                case 'deflate':
-                case 'x-deflate': {
-                    const newStream = zlib.createInflate();
-                    prev.pipe(newStream);
-                    return newStream;
-                }
-                case 'br': {
-                    const newStream = zlib.createBrotliDecompress();
-                    prev.pipe(newStream);
-                    return newStream;
-                }
-                case 'base64': {
-                    const newStream = new Base64Decode();
-                    prev.pipe(newStream);
-                    return newStream;
-                }
-                case 'identity':
-                    // prev.length = 0;
-                    return prev;
-                default:
-                    throw new BadRequestError({
-                        message: 'unsupported content encoding "' + encoding + '"',
-                        code: '',
-                        details: {
-                            encoding,
-                        },
-                    }, 415);
-            }
-        }, req);
-    }
-}

package/esm/http/utils/common.js

@@ -1,61 +0,0 @@
-/*
-  This file contains code blocks from open source NodeJs project
-  https://github.com/nodejs/
- */
-const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
-const nodeInternalPrefix = '__node_internal_';
-/**
- * Verifies that the given val is a valid HTTP token
- * per the rules defined in RFC 7230
- * See https://tools.ietf.org/html/rfc7230#section-3.2.6
- *
- * https://github.com/nodejs/node/blob/main/lib/_http_common.js
- */
-export function checkIsHttpToken(val) {
-    return typeof val === 'string' && tokenRegExp.exec(val) !== null;
-}
-const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
-/**
- * True if val contains an invalid field-vchar
- *  field-value    = *( field-content / obs-fold )
- *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
- *  field-vchar    = VCHAR / obs-text
- *
- *  https://github.com/nodejs/node/blob/main/lib/_http_common.js
- */
-function checkInvalidHeaderChar(val) {
-    // noinspection SuspiciousTypeOfGuard
-    return typeof val === 'string' && headerCharRegex.exec(val) !== null;
-}
-/**
- * This function removes unnecessary frames from Node.js core errors.
- *
- * https://github.com/nodejs/node/blob/main/lib/internal/errors.js
- */
-export function hideStackFrames(fn) {
-    // We rename the functions that will be hidden to cut off the stacktrace
-    // at the outermost one
-    const hidden = nodeInternalPrefix + fn.name;
-    // @ts-ignore
-    Object.defineProperty(fn, 'name', { __proto__: null, value: hidden });
-    return fn;
-}
-export const validateHeaderName = hideStackFrames((name, label) => {
-    // noinspection SuspiciousTypeOfGuard
-    if (typeof name !== 'string' || !name || !checkIsHttpToken(name)) {
-        throw new TypeError(`${label || 'Header name'} must be a valid HTTP token ["${name}"]`);
-    }
-});
-export const validateHeaderValue = hideStackFrames((name, value) => {
-    if (value === undefined) {
-        throw new TypeError(`Invalid value "${value}" for header "${name}"`);
-    }
-    if (checkInvalidHeaderChar(value)) {
-        throw new TypeError(`Invalid character in header content ["${name}"]`);
-    }
-});
-export function validateString(value, name) {
-    if (typeof value !== 'string') {
-        throw new TypeError(`Invalid ${name ? name + ' ' : ''}argument. Value must be a string`);
-    }
-}

package/esm/http/utils/concat-readable.js

@@ -1,16 +0,0 @@
-import { PassThrough } from 'stream';
-export function concatReadable(...streams) {
-    const out = new PassThrough();
-    const pipeNext = () => {
-        const nextStream = streams.shift();
-        if (nextStream) {
-            nextStream.pipe(out, { end: false });
-            nextStream.once('end', () => pipeNext());
-        }
-        else {
-            out.end();
-        }
-    };
-    pipeNext();
-    return out;
-}

package/esm/http/utils/convert-to-headers.js

@@ -1,60 +0,0 @@
-import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD, } from './match-known-fields.js';
-export function convertToHeaders(src, dst, joinDuplicateHeaders) {
-    for (let n = 0; n < src.length; n += 2) {
-        addHeaderLine(src[n], src[n + 1], dst, joinDuplicateHeaders);
-    }
-    return dst;
-}
-export function convertToHeadersDistinct(src, dst) {
-    const count = src.length % 2;
-    for (let n = 0; n < count; n += 2) {
-        addHeaderLineDistinct(src[n], src[n + 1], dst);
-    }
-    return dst;
-}
-function addHeaderLine(field, value, dest, joinDuplicateHeaders) {
-    if (value == null)
-        return;
-    field = field.toLowerCase();
-    const [, flag] = matchKnownFields(field);
-    // comma(0) or semicolon(2) delimited field
-    if (flag === COMMA_DELIMITED_FIELD || flag === SEMICOLON_DELIMITED_FIELD) {
-        // Make a delimited list
-        if (typeof dest[field] === 'string') {
-            dest[field] += (flag === COMMA_DELIMITED_FIELD ? ', ' : '; ') + value;
-        }
-        else {
-            dest[field] = value;
-        }
-    }
-    else if (flag === ARRAY_FIELD) {
-        // Array header -- only Set-Cookie at the moment
-        if (dest['set-cookie'] !== undefined) {
-            dest['set-cookie'].push(value);
-        }
-        else {
-            dest['set-cookie'] = [value];
-        }
-    }
-    else if (joinDuplicateHeaders) {
-        if (dest[field] === undefined) {
-            dest[field] = value;
-        }
-        else {
-            dest[field] += ', ' + value;
-        }
-    }
-    else if (dest[field] === undefined) {
-        // Drop duplicates
-        dest[field] = value;
-    }
-}
-function addHeaderLineDistinct(field, value, dest) {
-    field = field.toLowerCase();
-    if (!dest[field]) {
-        dest[field] = [value];
-    }
-    else {
-        dest[field].push(value);
-    }
-}

package/esm/http/utils/convert-to-raw-headers.js

@@ -1,20 +0,0 @@
-import { ARRAY_FIELD, COMMA_DELIMITED_FIELD, matchKnownFields, SEMICOLON_DELIMITED_FIELD, } from './match-known-fields.js';
-export function convertToRawHeaders(src) {
-    return Object.entries(src).reduce((a, [field, v]) => {
-        const [name, flag] = matchKnownFields(field);
-        if (flag === ARRAY_FIELD) {
-            if (Array.isArray(v))
-                v.forEach(x => a.push(name, String(x)));
-            else
-                a.push(name, String(v));
-            return a;
-        }
-        if (flag === COMMA_DELIMITED_FIELD || flag === SEMICOLON_DELIMITED_FIELD) {
-            v = Array.isArray(v) ? v.join(flag === COMMA_DELIMITED_FIELD ? ', ' : '; ') : String(v);
-        }
-        else
-            v = Array.isArray(v) ? String(v[0]) : String(v);
-        a.push(name, v);
-        return a;
-    }, []);
-}