@opra/core 0.18.4 → 0.20.0

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

@@ -0,0 +1,246 @@
+import * as stream from 'stream';
+import { HTTPParser } from '@browsery/http-parser';
+import { HttpHeaders } from '@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)$/;
+export class HttpMessageHost {
+    constructor() {
+        this.complete = false;
+        stream.Duplex.apply(this);
+        this[kHeaders] = new HttpHeaders(undefined, {
+            onChange: () => this._headersChanged = true
+        });
+        this[kTrailers] = new 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 HTTPParser(parserType);
+        parser[HTTPParser.kOnHeadersComplete] = this[kOnHeaderReceived].bind(this);
+        parser[HTTPParser.kOnBody] = this[kOnBodyChunk].bind(this);
+        parser[HTTPParser.kOnHeaders] = this[kOnTrailersReceived].bind(this);
+        parser[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;
+        }
+    }
+}
+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/esm/adapter/http/http-request-message.js

@@ -0,0 +1,148 @@
+import accepts from 'accepts';
+import typeIs from 'type-is';
+import { HTTPParser } from '@browsery/http-parser';
+import { HttpParams } from '@opra/common';
+import { HttpMessageHost } from './http-message.host.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;

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

@@ -0,0 +1,233 @@
+import contentDisposition from 'content-disposition';
+import cookie from 'cookie';
+import cookieSignature from 'cookie-signature';
+import encodeUrl from 'encodeurl';
+import mime from 'mime-types';
+import path from 'path';
+import { HTTPParser } from '@browsery/http-parser';
+import { HttpStatusMessages } from '@opra/common';
+import { HttpMessageHost } from './http-message.host.js';
+/**
+ * @namespace HttpResponseMessage
+ */
+export 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 || (HttpResponseMessage = {}));
+/**
+ * @class HttpResponseMessageHost
+ */
+export class HttpResponseMessageHost extends HttpMessageHost {
+    constructor() {
+        super();
+    }
+    header(arg0, arg1) {
+        return this.set(arg0, arg1);
+    }
+    append(name, value) {
+        this[HttpMessageHost.kHeaders].append(name, value);
+        return this;
+    }
+    /**
+     * Set "Content-Disposition" header to "attachment" with optional `filename`.
+     */
+    attachment(filename) {
+        if (filename)
+            this.type(path.extname(filename));
+        this.set('Content-Disposition', contentDisposition(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.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:' + cookieSignature.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.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', encodeUrl(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 = 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;
+    }
+    [HttpMessageHost.kOnHeaderReceived](info) {
+        super[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, 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');
+    }
+}

package/esm/adapter/internal/metadata.resource.js

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from "tslib";
 import { ApiDocument, cloneObject, Singleton } from '@opra/common';
-let MetadataResource = class MetadataResource {
+export let MetadataResource = class MetadataResource {
     constructor(document) {
         this.document = document;
         this._schema = document.exportSchema();
@@ -21,4 +21,3 @@ MetadataResource = __decorate([
     }),
     __metadata("design:paramtypes", [ApiDocument])
 ], MetadataResource);
-export { MetadataResource };

package/esm/index.js

@@ -4,6 +4,8 @@ export * from './types.js';
 export * from './adapter/adapter.js';
 export * from './adapter/http/express-adapter.js';
 export * from './adapter/http/http-adapter.js';
+export * from './adapter/http/http-request-message.js';
+export * from './adapter/http/http-response-message.js';
 export * from './adapter/interfaces/request-context.interface.js';
 export * from './adapter/interfaces/logger.interface.js';
 export * from './adapter/interfaces/request.interface.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.18.4",
+  "version": "0.20.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -27,26 +27,38 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/common": "^0.18.4",
+    "@opra/common": "^0.20.0",
+    "accepts": "^1.3.8",
+    "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
+    "cookie": "^0.5.0",
     "lodash.isnil": "^4.0.0",
     "lodash.omitby": "^4.6.0",
-    "power-tasks": "^1.6.4",
+    "mime-types": "^2.1.35",
+    "power-tasks": "^1.7.0",
     "putil-isplainobject": "^1.1.5",
     "putil-merge": "^3.10.3",
     "putil-varhelpers": "^1.6.5",
-    "strict-typed-events": "^2.3.1"
+    "strict-typed-events": "^2.3.1",
+    "type-is": "^1.6.18"
   },
   "peerDependencies": {
     "body-parser": "^1.20.2",
     "express": "^4.x.x || ^5.x.x"
   },
   "devDependencies": {
-    "@faker-js/faker": "^8.0.0",
+    "@faker-js/faker": "^8.0.2",
+    "@types/accepts": "^1.3.5",
+    "@types/content-disposition": "^0.5.5",
     "@types/content-type": "^1.1.5",
+    "@types/cookie": "^0.5.1",
     "@types/dicer": "^0.2.2",
     "@types/express": "^4.17.17",
+    "@types/mime-types": "^2.1.1",
+    "@types/type-is": "^1.6.3",
     "cors": "^2.8.5",
+    "crypto-browserify": "^3.12.0",
+    "path-browserify": "^1.0.1",
     "ts-gems": "^2.4.0"
   },
   "type": "module",