@opra/core 0.21.0 → 0.23.0

package/cjs/adapter/http/{impl/http-server-response.js → http-server-response.js}

@@ -16,20 +16,20 @@ const path_1 = tslib_1.__importDefault(require("path"));
 const putil_varhelpers_1 = require("putil-varhelpers");
 const vary_1 = tslib_1.__importDefault(require("vary"));
 const common_1 = require("@opra/common");
-const http_outgoing_message_host_js_1 = require("./http-outgoing-message-host.js");
+const http_outgoing_message_host_js_1 = require("./impl/http-outgoing-message.host.js");
 const charsetRegExp = /;\s*charset\s*=/;
 function isHttpIncomingMessage(v) {
     return v && typeof v.getHeaders === 'function' && (0, common_1.isStream)(v);
 }
 var HttpServerResponse;
 (function (HttpServerResponse) {
-    function create(instance) {
+    function from(instance) {
         if (!isHttpIncomingMessage(instance))
-            instance = http_outgoing_message_host_js_1.HttpOutgoingMessageHost.create(instance);
+            instance = new http_outgoing_message_host_js_1.HttpOutgoingMessageHost(instance);
         (0, common_1.mergePrototype)(instance, HttpServerResponseHost.prototype);
         return instance;
     }
-    HttpServerResponse.create = create;
+    HttpServerResponse.from = from;
 })(HttpServerResponse || (exports.HttpServerResponse = HttpServerResponse = {}));
 class HttpServerResponseHost {
     attachment(filename) {
@@ -47,28 +47,28 @@ class HttpServerResponseHost {
     }
     setHeader(field, val) {
         const setHeader = Object.getPrototypeOf(this).setHeader;
-        if (typeof field === 'string') {
-            let value = Array.isArray(val)
-                ? val.map(String)
-                : (val ? String(val) : '');
-            // add charset to content-type
-            if (field.toLowerCase() === 'content-type') {
-                if (Array.isArray(value)) {
-                    throw new TypeError('Content-Type cannot be set to an Array');
-                }
-                if (!charsetRegExp.test(value)) {
-                    const charset = mime_types_1.default.charsets.lookup(value.split(';')[0]);
-                    if (charset)
-                        value += '; charset=' + charset.toLowerCase();
-                }
-            }
-            setHeader.call(this, field, value);
-        }
-        else {
+        if (typeof field === 'object') {
             for (const [k, v] of Object.entries(field)) {
                 this.setHeader(k, v);
             }
+            return this;
+        }
+        const fieldLower = field.toLowerCase();
+        let value = Array.isArray(val)
+            ? val.map(String)
+            : (val ? String(val) : '');
+        // add charset to content-type
+        if (fieldLower === 'content-type') {
+            if (Array.isArray(value)) {
+                throw new TypeError('Content-Type cannot be set to an Array');
+            }
+            if (!charsetRegExp.test(value)) {
+                const charset = mime_types_1.default.charsets.lookup(value.split(';')[0]);
+                if (charset)
+                    value += '; charset=' + charset.toLowerCase();
+            }
         }
+        setHeader.call(this, field, value);
         return this;
     }
     clearCookie(name, options) {

package/cjs/adapter/http/impl/http-incoming-message.host.js

@@ -0,0 +1,148 @@
+"use strict";
+/*
+  This file contains code blocks from open source NodeJs project
+  https://github.com/nodejs/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpIncomingMessageHost = exports.kTrailersDistinct = exports.kTrailers = exports.kHeadersDistinct = exports.kHeaders = exports.CRLF = void 0;
+const stream_1 = require("stream");
+const http_parser_1 = require("@browsery/http-parser");
+const common_1 = require("@opra/common");
+const concat_readable_js_1 = require("../helpers/concat-readable.js");
+const convert_to_headers_js_1 = require("../helpers/convert-to-headers.js");
+const convert_to_raw_headers_js_1 = require("../helpers/convert-to-raw-headers.js");
+exports.CRLF = Buffer.from('\r\n');
+exports.kHeaders = Symbol.for('kHeaders');
+exports.kHeadersDistinct = Symbol.for('kHeadersDistinct');
+exports.kTrailers = Symbol.for('kTrailers');
+exports.kTrailersDistinct = Symbol.for('kTrailersDistinct');
+/**
+ *
+ * @class HttpIncomingMessageHost
+ */
+class HttpIncomingMessageHost extends stream_1.Duplex {
+    constructor(init) {
+        super();
+        this.rawHeaders = [];
+        this.rawTrailers = [];
+        this.complete = false;
+        this.joinDuplicateHeaders = false;
+        if (init) {
+            this.complete = true;
+            this.httpVersionMajor = init.httpVersionMajor || 1;
+            this.httpVersionMinor = init.httpVersionMinor || 0;
+            this.method = (init.method || 'GET').toUpperCase();
+            this.url = init.url || '';
+            if (init.body != null) {
+                if (Buffer.isBuffer(init.body))
+                    this.body = init.body;
+                else if (typeof init.body === 'string')
+                    this.body = Buffer.from(init.body, 'utf-8');
+                else
+                    this.body = Buffer.from(JSON.stringify(init.body), 'utf-8');
+            }
+            if (init.headers)
+                this.rawHeaders = Array.isArray(init.headers) ? init.headers : (0, convert_to_raw_headers_js_1.convertToRawHeaders)(init.headers);
+            if (init.trailers)
+                this.rawTrailers = Array.isArray(init.trailers) ? init.trailers : (0, convert_to_raw_headers_js_1.convertToRawHeaders)(init.trailers);
+            this.ip = init.ip || '';
+            this.ips = init.ips || (this.ip ? [this.ip] : []);
+            if (this.body && !this.headers['content-length'])
+                this.headers['content-length'] = String(this.body.length);
+        }
+    }
+    get httpVersion() {
+        return this.httpVersionMajor
+            ? this.httpVersionMajor + '.' + this.httpVersionMinor
+            : '';
+    }
+    get headers() {
+        if (!this[exports.kHeaders])
+            this[exports.kHeaders] = (0, convert_to_headers_js_1.convertToHeaders)(this.rawHeaders, {}, this.joinDuplicateHeaders);
+        return this[exports.kHeaders];
+    }
+    set headers(headers) {
+        this[exports.kHeaders] = headers;
+    }
+    get headersDistinct() {
+        if (!this[exports.kHeadersDistinct])
+            this[exports.kHeadersDistinct] = (0, convert_to_headers_js_1.convertToHeadersDistinct)(this.rawHeaders, {});
+        return this[exports.kHeadersDistinct];
+    }
+    get trailers() {
+        if (!this[exports.kTrailers])
+            this[exports.kTrailers] = (0, convert_to_headers_js_1.convertToHeaders)(this.rawTrailers, {}, this.joinDuplicateHeaders);
+        return this[exports.kTrailers];
+    }
+    set trailers(trailers) {
+        this[exports.kTrailers] = trailers;
+    }
+    get trailersDistinct() {
+        if (!this[exports.kTrailersDistinct])
+            this[exports.kTrailersDistinct] = (0, convert_to_headers_js_1.convertToHeadersDistinct)(this.rawTrailers, {});
+        return this[exports.kTrailersDistinct];
+    }
+    _read(size) {
+        if (!this.body) {
+            this.push(null);
+            return;
+        }
+        if (!this._readStream) {
+            if ((0, common_1.isIterable)(this.body) || (0, common_1.isAsyncIterable)(this.body))
+                this._readStream = stream_1.Readable.from(this.body);
+            else if (typeof this.body === 'string') {
+                this._readStream = stream_1.Readable.from(Buffer.from(this.body, 'utf-8'));
+            }
+            else
+                this._readStream = stream_1.Readable.from(Buffer.from(JSON.stringify(this.body), 'utf-8'));
+        }
+        const chunk = this._readStream.read(size);
+        this.push(chunk);
+        // this.push(null);s
+    }
+    _write(chunk, encoding, callback) {
+        const error = this._httpParser?.execute(chunk);
+        if (error && typeof error === 'object')
+            callback(error);
+        else
+            callback();
+    }
+    static from(iterable) {
+        if (typeof iterable === 'object' && !((0, common_1.isIterable)(iterable) || (0, common_1.isAsyncIterable)(iterable)))
+            return new HttpIncomingMessageHost(iterable);
+        const msg = new HttpIncomingMessageHost();
+        const parser = msg._httpParser = new http_parser_1.HTTPParser(http_parser_1.HTTPParser.REQUEST);
+        let bodyChunks;
+        parser[http_parser_1.HTTPParser.kOnHeadersComplete] = (info) => {
+            msg.httpVersionMajor = info.versionMajor;
+            msg.httpVersionMinor = info.versionMinor;
+            msg.rawHeaders = info.headers;
+            msg.method = http_parser_1.HTTPParser.methods[info.method];
+            msg.url = info.url;
+        };
+        parser[http_parser_1.HTTPParser.kOnHeaders] = (trailers) => {
+            msg.rawTrailers = trailers;
+        };
+        parser[http_parser_1.HTTPParser.kOnBody] = (chunk, offset, length) => {
+            bodyChunks = bodyChunks || [];
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        parser[http_parser_1.HTTPParser.kOnMessageComplete] = () => {
+            msg.complete = true;
+            if (bodyChunks)
+                msg.body = Buffer.concat(bodyChunks);
+        };
+        const readable = (0, concat_readable_js_1.concatReadable)(stream_1.Readable.from(iterable), stream_1.Readable.from(exports.CRLF));
+        msg.once('finish', () => parser.finish());
+        readable.pipe(msg);
+        return msg;
+    }
+    static async fromAsync(iterable) {
+        return new Promise((resolve, reject) => {
+            const msg = this.from(iterable);
+            msg.once('finish', () => resolve(msg));
+            msg.once('error', (error) => reject(error));
+        });
+    }
+}
+exports.HttpIncomingMessageHost = HttpIncomingMessageHost;

package/cjs/adapter/http/impl/{http-outgoing-message-host.js → http-outgoing-message.host.js}

@@ -3,36 +3,42 @@
   This file contains code blocks from open source NodeJs project
   https://github.com/nodejs/
  */
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpOutgoingMessageHost = exports.kErrored = exports.kOutTrailers = exports.kOutHeaders = void 0;
-const tslib_1 = require("tslib");
-const stream = tslib_1.__importStar(require("stream"));
+exports.HttpOutgoingMessageHost = exports.kOutTrailers = exports.kOutHeaders = void 0;
+const stream_1 = require("stream");
 const common_js_1 = require("../helpers/common.js");
-exports.kOutHeaders = Symbol('kOutHeaders');
-exports.kOutTrailers = Symbol('kOutTrailers');
-exports.kErrored = Symbol('kErrored');
+exports.kOutHeaders = Symbol.for('kOutHeaders');
+exports.kOutTrailers = Symbol.for('kOutTrailers');
 // noinspection JSUnusedLocalSymbols
 /**
  *
  * @class HttpOutgoingMessageHost
  */
-class HttpOutgoingMessageHost {
-    constructor() {
+class HttpOutgoingMessageHost extends stream_1.Duplex {
+    constructor(init) {
+        super();
         this._headersSent = false;
-        this._closed = false;
-        this[_a] = null;
         this.finished = false;
-        stream.Stream.apply(this);
+        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 headersSent() {
-        return this._headersSent;
+    get httpVersionMajor() {
+        return this.req?.httpVersionMajor || this._httpVersionMajor;
     }
-    get closed() {
-        return this._closed;
+    get httpVersionMinor() {
+        return this.req?.httpVersionMinor || this._httpVersionMinor;
     }
-    get errored() {
-        return this[exports.kErrored];
+    get headersSent() {
+        return this._headersSent;
     }
     appendHeader(name, value) {
         if (this.headersSent)
@@ -185,26 +191,8 @@ class HttpOutgoingMessageHost {
         //
         return this;
     }
-    _readConfig(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;
-    }
-    static create(init) {
-        const msg = new HttpOutgoingMessageHost();
-        if (init)
-            msg._readConfig(init);
-        return msg;
+    static from(init) {
+        return new HttpOutgoingMessageHost(init);
     }
 }
 exports.HttpOutgoingMessageHost = HttpOutgoingMessageHost;
-_a = exports.kErrored;
-// Apply mixins
-Object.assign(HttpOutgoingMessageHost.prototype, stream.Stream.prototype);