@opra/core 0.19.0 → 0.20.1

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

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMessageHost = void 0;
+const tslib_1 = require("tslib");
+const stream = tslib_1.__importStar(require("stream"));
+const http_parser_1 = require("@browsery/http-parser");
+const common_1 = require("@opra/common");
+const kHeaders = Symbol('kHeaders');
+const kHeadersProxy = Symbol('kHeadersProxy');
+const kTrailers = Symbol('kTrailers');
+const kTrailersProxy = Symbol('kTrailersProxy');
+const kOnHeaderReceived = Symbol('kOnHeaderReceived');
+const kOnTrailersReceived = Symbol('kOnTrailersReceived');
+const kOnBodyChunk = Symbol('kOnBodyChunk');
+const kOnReadComplete = Symbol('kOnReadComplete');
+const crlfBuffer = Buffer.from('\r\n');
+const HTTP_VERSION_PATTERN = /^(\d)\.(\d)$/;
+class HttpMessageHost {
+    constructor() {
+        this.complete = false;
+        stream.Duplex.apply(this);
+        this[kHeaders] = new common_1.HttpHeaders(undefined, {
+            onChange: () => this._headersChanged = true
+        });
+        this[kTrailers] = new common_1.HttpHeaders(undefined, {
+            onChange: () => this._trailersChanged = true
+        });
+    }
+    get httpVersion() {
+        return this.httpVersionMajor
+            ? this.httpVersionMajor + '.' + (this.httpVersionMinor || 0)
+            : undefined;
+    }
+    set httpVersion(value) {
+        if (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);
+        }
+        else {
+            this.httpVersionMajor = undefined;
+            this.httpVersionMinor = undefined;
+        }
+    }
+    get headers() {
+        this._initHeaders();
+        return this[kHeadersProxy];
+    }
+    set headers(headers) {
+        this[kHeaders].clear();
+        this[kHeaders].set(headers);
+    }
+    get trailers() {
+        this._initTrailers();
+        return this[kTrailersProxy];
+    }
+    set trailers(trailers) {
+        this[kTrailers].clear();
+        this[kTrailers].set(trailers);
+    }
+    get rawHeaders() {
+        this._buildRawHeaders();
+        return this._rawHeaders;
+    }
+    set rawHeaders(headers) {
+        this[kHeadersProxy] = undefined;
+        this._headersChanged = false;
+        this._rawHeaders = headers;
+    }
+    get rawTrailers() {
+        this._buildRawTrailers();
+        return this._rawTrailers;
+    }
+    set rawTrailers(trailers) {
+        this[kTrailersProxy] = undefined;
+        this._trailersChanged = false;
+        this._rawTrailers = trailers;
+    }
+    getHeader(name) {
+        if (!name)
+            return;
+        this._initHeaders();
+        switch (name.toLowerCase()) {
+            case 'referer':
+            case 'referrer':
+                return this[kHeaders].get(name) ||
+                    this[kHeaders].get('referrer') ||
+                    this[kHeaders].get('referer');
+            default:
+                return this[kHeaders].get(name);
+        }
+    }
+    get(name) {
+        this._initHeaders();
+        return this[kHeaders].get(name);
+    }
+    setHeader(arg0, arg1) {
+        this._initHeaders();
+        if (typeof arg0 === 'object')
+            this[kHeaders].set(arg0);
+        else
+            this[kHeaders].set(arg0, arg1);
+        return this;
+    }
+    set(arg0, arg1) {
+        return this.setHeader(arg0, arg1);
+    }
+    getHeaders() {
+        this._initHeaders();
+        return this[kHeaders].toObject();
+    }
+    getHeaderNames() {
+        this._initHeaders();
+        return Array.from(this[kHeaders].keys());
+    }
+    hasHeader(name) {
+        this._initHeaders();
+        return this[kHeaders].has(name);
+    }
+    removeHeader(name) {
+        this._initHeaders();
+        this[kHeaders].delete(name);
+    }
+    send(body) {
+        this.body = body;
+        return this;
+    }
+    end(body) {
+        if (body)
+            this.body = body;
+        return this;
+    }
+    setTimeout() {
+        return this;
+    }
+    _init(args) {
+        this.complete = true;
+        this.httpVersionMajor = args?.httpVersionMajor;
+        this.httpVersionMinor = args?.httpVersionMinor;
+        this._rawHeaders = args.rawHeaders;
+        this._rawTrailers = args.rawTrailers;
+        if (args.headers)
+            this[kHeaders].set(args.headers);
+        if (args.trailers)
+            this[kTrailers].set(args.trailers);
+        this.body = args.body;
+    }
+    _parseBuffer(buf, parserType) {
+        const parser = new http_parser_1.HTTPParser(parserType);
+        parser[http_parser_1.HTTPParser.kOnHeadersComplete] = this[kOnHeaderReceived].bind(this);
+        parser[http_parser_1.HTTPParser.kOnBody] = this[kOnBodyChunk].bind(this);
+        parser[http_parser_1.HTTPParser.kOnHeaders] = this[kOnTrailersReceived].bind(this);
+        parser[http_parser_1.HTTPParser.kOnMessageComplete] = this[kOnReadComplete].bind(this);
+        const buffer = Buffer.from(buf);
+        let x = parser.execute(buffer);
+        if (typeof x === 'object')
+            throw x;
+        if (!this.complete) {
+            x = parser.execute(crlfBuffer);
+            if (typeof x === 'object')
+                throw x;
+        }
+        parser.finish();
+    }
+    _initHeaders() {
+        if (!this[kHeadersProxy]) {
+            this[kHeadersProxy] = this[kHeaders].getProxy();
+            if (this._rawHeaders) {
+                const src = this._rawHeaders;
+                const l = Math.floor(src.length / 2);
+                for (let n = 0; n <= l; n += 2) {
+                    this[kHeaders].append(src[n], src[n + 1]);
+                }
+            }
+        }
+    }
+    _initTrailers() {
+        if (!this[kTrailersProxy]) {
+            this[kTrailersProxy] = this[kTrailers].getProxy();
+            if (this._rawTrailers) {
+                const src = this._rawTrailers;
+                const l = Math.floor(src.length / 2);
+                for (let n = 0; n <= l; n += 2) {
+                    this[kTrailers].append(src[n], src[n + 1]);
+                }
+            }
+        }
+    }
+    _buildRawHeaders() {
+        // Rebuild rawHeaders if headers object changed
+        if (this._headersChanged || !this._rawHeaders) {
+            this._headersChanged = false;
+            this._rawHeaders = Object.entries(this.headers)
+                .reduce((a, [k, v]) => {
+                if (Array.isArray(v))
+                    v.forEach(x => a.push(k, String(x)));
+                else
+                    a.push(k, String(v));
+                return a;
+            }, []);
+        }
+    }
+    _buildRawTrailers() {
+        // Rebuild rawHeaders if headers object changed
+        if (this._trailersChanged || !this._rawTrailers) {
+            this._trailersChanged = false;
+            this._rawTrailers = Object.entries(this.trailers)
+                .reduce((a, [k, v]) => {
+                if (Array.isArray(v))
+                    v.forEach(x => a.push(k, String(x)));
+                else
+                    a.push(k, String(v));
+                return a;
+            }, []);
+        }
+    }
+    [kOnHeaderReceived](info) {
+        this.httpVersionMajor = info.versionMajor;
+        this.httpVersionMinor = info.versionMinor;
+        this._rawHeaders = info.headers;
+        this.shouldKeepAlive = info.shouldKeepAlive;
+        this.upgrade = info.upgrade;
+    }
+    [kOnTrailersReceived](trailers) {
+        this._rawTrailers = trailers;
+    }
+    [kOnBodyChunk](chunk, offset, length) {
+        this._bodyChunks = this._bodyChunks || [];
+        this._bodyChunks.push(chunk.subarray(offset, offset + length));
+    }
+    [kOnReadComplete]() {
+        this.complete = true;
+        if (this._bodyChunks) {
+            this.body = Buffer.concat(this._bodyChunks);
+            this._bodyChunks = undefined;
+        }
+    }
+}
+exports.HttpMessageHost = HttpMessageHost;
+HttpMessageHost.kHeaders = kHeaders;
+HttpMessageHost.kHeadersProxy = kHeadersProxy;
+HttpMessageHost.kTrailers = kTrailers;
+HttpMessageHost.kTrailersProxy = kTrailersProxy;
+HttpMessageHost.kOnHeaderReceived = kOnHeaderReceived;
+HttpMessageHost.kOnTrailersReceived = kOnTrailersReceived;
+HttpMessageHost.kOnBodyChunk = kOnBodyChunk;
+HttpMessageHost.kOnReadComplete = kOnReadComplete;
+// Mixin with Duplex
+Object.assign(HttpMessageHost.prototype, stream.Duplex.prototype);

package/cjs/adapter/http/http-request-message.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestMessage = void 0;
+const tslib_1 = require("tslib");
+const accepts_1 = tslib_1.__importDefault(require("accepts"));
+const type_is_1 = tslib_1.__importDefault(require("type-is"));
+const http_parser_1 = require("@browsery/http-parser");
+const common_1 = require("@opra/common");
+const http_message_host_js_1 = require("./http-message.host.js");
+const HTTP_VERSION_PATTERN = /^(\d)\.(\d)$/;
+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 || (exports.HttpRequestMessage = HttpRequestMessage = {}));
+const kQuery = Symbol('kQuery');
+const kQueryProxy = Symbol('kQueryProxy');
+const kProtocol = Symbol('kProtocol');
+/**
+ *
+ */
+class HttpRequestMessageHost extends http_message_host_js_1.HttpMessageHost {
+    constructor() {
+        super();
+        this.httpVersionMajor = 1;
+        this.httpVersionMinor = 0;
+        this[kQuery] = new common_1.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 = (0, accepts_1.default)(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.types.apply(accept, type);
+    }
+    acceptsCharsets(...charset) {
+        const accept = (0, accepts_1.default)(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.charsets.apply(accept, charset);
+    }
+    acceptsEncodings(...encoding) {
+        const accept = (0, accepts_1.default)(this);
+        // eslint-disable-next-line prefer-spread
+        return accept.encodings.apply(accept, encoding);
+    }
+    acceptsLanguages(...lang) {
+        const accept = (0, accepts_1.default)(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 ? type_is_1.default.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;
+    }
+    [http_message_host_js_1.HttpMessageHost.kOnHeaderReceived](info) {
+        super[http_message_host_js_1.HttpMessageHost.kOnHeaderReceived](info);
+        this.method = http_parser_1.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, http_parser_1.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;

package/cjs/adapter/http/http-response-message.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponseMessageHost = exports.HttpResponseMessage = void 0;
+const tslib_1 = require("tslib");
+const content_disposition_1 = tslib_1.__importDefault(require("content-disposition"));
+const cookie_1 = tslib_1.__importDefault(require("cookie"));
+const cookie_signature_1 = tslib_1.__importDefault(require("cookie-signature"));
+const encodeurl_1 = tslib_1.__importDefault(require("encodeurl"));
+const mime_types_1 = tslib_1.__importDefault(require("mime-types"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const http_parser_1 = require("@browsery/http-parser");
+const common_1 = require("@opra/common");
+const http_message_host_js_1 = require("./http-message.host.js");
+/**
+ * @namespace HttpResponseMessage
+ */
+var HttpResponseMessage;
+(function (HttpResponseMessage) {
+    function create(init) {
+        return HttpResponseMessageHost.create(init);
+    }
+    HttpResponseMessage.create = create;
+    function fromBuffer(buffer) {
+        return HttpResponseMessageHost.fromBuffer(buffer);
+    }
+    HttpResponseMessage.fromBuffer = fromBuffer;
+    async function fromStream(readable) {
+        return HttpResponseMessageHost.fromStream(readable);
+    }
+    HttpResponseMessage.fromStream = fromStream;
+})(HttpResponseMessage || (exports.HttpResponseMessage = HttpResponseMessage = {}));
+/**
+ * @class HttpResponseMessageHost
+ */
+class HttpResponseMessageHost extends http_message_host_js_1.HttpMessageHost {
+    constructor() {
+        super();
+    }
+    header(arg0, arg1) {
+        return this.set(arg0, arg1);
+    }
+    append(name, value) {
+        this[http_message_host_js_1.HttpMessageHost.kHeaders].append(name, value);
+        return this;
+    }
+    /**
+     * Set "Content-Disposition" header to "attachment" with optional `filename`.
+     */
+    attachment(filename) {
+        if (filename)
+            this.type(path_1.default.extname(filename));
+        this.set('Content-Disposition', (0, content_disposition_1.default)(filename));
+        return this;
+    }
+    /**
+     * Alias for msg.type()
+     */
+    contentType(type) {
+        return this.type(type);
+    }
+    /**
+     * 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) {
+        const ct = type.indexOf('/') === -1
+            ? mime_types_1.default.lookup(type)
+            : type;
+        if (ct)
+            this.set('Content-Type', ct);
+        return 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, value, options) {
+        const opts = { ...options };
+        const secret = this.req?.secret;
+        const signed = opts.signed;
+        if (signed && !secret) {
+            throw new Error('cookieParser("secret") required for signed cookies');
+        }
+        let val = typeof value === 'object'
+            ? 'j:' + JSON.stringify(value)
+            : String(value);
+        if (signed)
+            val = 's:' + cookie_signature_1.default.sign(val, secret);
+        if (opts.maxAge != null) {
+            const maxAge = opts.maxAge - 0;
+            if (!isNaN(maxAge)) {
+                opts.expires = new Date(Date.now() + maxAge);
+                opts.maxAge = Math.floor(maxAge / 1000);
+            }
+        }
+        if (opts.path == null)
+            opts.path = '/';
+        // Remove old cookie
+        let a = this.get('Set-Cookie');
+        if (a && Array.isArray(a)) {
+            a = a.filter(x => !x.startsWith(name + '='));
+            this.set('Set-Cookie', a);
+        }
+        this.append('Set-Cookie', cookie_1.default.serialize(name, String(val), opts));
+        return this;
+    }
+    /**
+     * Clear cookie `name`.
+     */
+    clearCookie(name, options) {
+        return this.cookie(name, '', { expires: new Date(1), path: '/', ...options });
+    }
+    /**
+     * 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) {
+        let link = this.get('Link') || '';
+        if (link)
+            link += ', ';
+        return this.set('Link', link + Object.keys(links).map(rel => '<' + links[rel] + '>; rel="' + rel + '"').join(', '));
+    }
+    redirect(arg0, url) {
+        let status = 302;
+        // allow status / url
+        if (typeof arg0 === 'number') {
+            status = arg0;
+        }
+        else
+            url = arg0 || '';
+        // Set location header
+        this.location(url || '/');
+        // Respond
+        this.statusCode = status;
+    }
+    /**
+     * Send JSON response.
+     *
+     * Examples:
+     *
+     *     res.json(null);
+     *     res.json({ user: 'tj' });
+     */
+    json(obj) {
+        if (!this.get('Content-Type'))
+            this.set('Content-Type', 'application/json');
+        const body = JSON.stringify(obj);
+        return this.send(body);
+    }
+    location(url) {
+        let loc = url;
+        // "back" is an alias for the referrer
+        if (url === 'back')
+            loc = this.req?.get('Referrer') || '/';
+        // set location
+        return this.set('Location', (0, encodeurl_1.default)(loc));
+    }
+    /**
+     * Set status `code`.
+     */
+    status(code) {
+        this.statusCode = code;
+        return 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) {
+        const body = common_1.HttpStatusMessages[statusCode] || String(statusCode);
+        this.statusCode = statusCode;
+        this.type('txt');
+        return this.send(body);
+    }
+    _init(init) {
+        super._init(init);
+        this.statusCode = init?.statusCode;
+        this.statusMessage = init?.statusMessage;
+        this.req = init?.req;
+        this.chunkedEncoding = init?.chunkedEncoding;
+    }
+    [http_message_host_js_1.HttpMessageHost.kOnHeaderReceived](info) {
+        super[http_message_host_js_1.HttpMessageHost.kOnHeaderReceived](info);
+        this.statusCode = info.statusCode;
+        this.statusMessage = info.statusMessage;
+    }
+    static create(init) {
+        const msg = new HttpResponseMessageHost();
+        msg._init(init);
+        return msg;
+    }
+    static fromBuffer(buffer) {
+        const msg = new HttpResponseMessageHost();
+        msg._parseBuffer(buffer, http_parser_1.HTTPParser.RESPONSE);
+        return msg;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static async fromStream(readable) {
+        throw new Error('fromStream is not implemented yet');
+    }
+}
+exports.HttpResponseMessageHost = HttpResponseMessageHost;

package/cjs/index.js

@@ -7,6 +7,8 @@ tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./adapter/adapter.js"), exports);
 tslib_1.__exportStar(require("./adapter/http/express-adapter.js"), exports);
 tslib_1.__exportStar(require("./adapter/http/http-adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/http-request-message.js"), exports);
+tslib_1.__exportStar(require("./adapter/http/http-response-message.js"), exports);
 tslib_1.__exportStar(require("./adapter/interfaces/request-context.interface.js"), exports);
 tslib_1.__exportStar(require("./adapter/interfaces/logger.interface.js"), exports);
 tslib_1.__exportStar(require("./adapter/interfaces/request.interface.js"), exports);