@opra/core 1.0.0-beta.1 → 1.0.0-beta.3

package/esm/http/impl/http-incoming.host.js

@@ -1,107 +0,0 @@
-/*
-  Some parts of this file contains codes from open source express library
-  https://github.com/expressjs
- */
-import typeIs from '@browsery/type-is';
-import accepts from 'accepts';
-import fresh from 'fresh';
-import parseRange from 'range-parser';
-import { BodyReader } from '../utils/body-reader.js';
-export class HttpIncomingHost {
-    get protocol() {
-        const proto = this.header('X-Forwarded-Proto') || 'http';
-        const index = proto.indexOf(',');
-        return index !== -1 ? proto.substring(0, index).trim() : proto.trim();
-    }
-    get secure() {
-        return this.protocol === 'https';
-    }
-    get hostname() {
-        let host = this.get('X-Forwarded-Host');
-        if (!host) {
-            host = this.get('Host');
-        }
-        else if (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(',')).trim();
-        }
-        if (host) {
-            // IPv6 literal support
-            const offset = host[0] === '[' ? host.indexOf(']') + 1 : 0;
-            const index = host.indexOf(':', offset);
-            return index !== -1 ? host.substring(0, index) : host;
-        }
-        return '';
-    }
-    get fresh() {
-        const method = this.method;
-        // GET or HEAD for weak freshness validation only
-        if (method !== 'GET' && method !== 'HEAD')
-            return false;
-        const status = this.res?.statusCode;
-        // 2xx or 304 as per rfc2616 14.26
-        if ((status >= 200 && status < 300) || status === 304) {
-            return fresh(this.headers, {
-                etag: this.res.getHeader('ETag'),
-                'last-modified': this.res.getHeader('Last-Modified'),
-            });
-        }
-        return false;
-    }
-    get xhr() {
-        const val = this.get('X-Requested-With') || '';
-        return val.toLowerCase() === 'xmlhttprequest';
-    }
-    header(name) {
-        name = name.toLowerCase();
-        const headers = this.headers;
-        switch (name) {
-            case 'referer':
-                return headers.referer || headers.referrer;
-            case 'referrer':
-                return headers.referrer || headers.referer;
-            default:
-                return headers[name];
-        }
-    }
-    get(name) {
-        return this.header(name);
-    }
-    accepts(...types) {
-        const accept = accepts(this);
-        return accept.types.call(accept, ...types);
-    }
-    acceptsCharsets(...charsets) {
-        const accept = accepts(this);
-        return accept.charsets.call(accept, ...charsets);
-    }
-    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.header('content-type');
-        return contentType ? typeIs.is(contentType, types) : null;
-    }
-    range(size, options) {
-        const range = this.header('range');
-        if (!range)
-            return;
-        return parseRange(size, range, options);
-    }
-    async readBody(options) {
-        if (!this.complete)
-            this.body = await BodyReader.read(this, options);
-        return this.body;
-    }
-}

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

@@ -1,202 +0,0 @@
-/*
-  Some parts of this file contains codes from open source express library
-  https://github.com/expressjs
- */
-import path from 'node:path';
-import { HttpStatusCode } from '@opra/common';
-import contentDisposition from 'content-disposition';
-import contentType from 'content-type';
-import cookie from 'cookie';
-import cookieSignature from 'cookie-signature';
-import encodeUrl from 'encodeurl';
-import mime from 'mime-types';
-import { toString } from 'putil-varhelpers';
-import vary from 'vary';
-const charsetRegExp = /;\s*charset\s*=/;
-export class HttpOutgoingHost {
-    attachment(filename) {
-        if (filename)
-            this.contentType(path.extname(filename));
-        this.setHeader('Content-Disposition', contentDisposition(filename));
-        return this;
-    }
-    contentType(type) {
-        const ct = type.indexOf('/') === -1 ? mime.lookup(type) : type;
-        this.setHeader('Content-Type', ct);
-        return this;
-    }
-    setHeader(field, val) {
-        const setHeader = Object.getPrototypeOf(this).setHeader;
-        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.charsets.lookup(value.split(';')[0]);
-                if (charset)
-                    value += '; charset=' + charset.toLowerCase();
-            }
-        }
-        setHeader.call(this, field, value);
-        return this;
-    }
-    clearCookie(name, options) {
-        const opts = {
-            expires: new Date(1),
-            path: '/',
-            ...options,
-        };
-        return this.cookie(name, '', opts);
-    }
-    cookie(name, value, options) {
-        const opts = { ...options };
-        let val = typeof value === 'object' ? 'j:' + JSON.stringify(value) : String(value);
-        if (opts.signed) {
-            const secret = opts.secret || this.req?.secret;
-            if (!secret)
-                throw new Error('"secret" required for signed cookies');
-            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 = '/';
-        this.appendHeader('Set-Cookie', cookie.serialize(name, String(val), opts));
-        return this;
-    }
-    status(code) {
-        this.statusCode = code;
-        return this;
-    }
-    sendStatus(statusCode) {
-        const body = HttpStatusCode[statusCode] || String(statusCode);
-        this.statusCode = statusCode;
-        this.contentType('txt');
-        return this.send(body);
-    }
-    links(links) {
-        let link = this.getHeader('Link') || '';
-        if (link)
-            link += ', ';
-        this.setHeader('Link', link +
-            Object.keys(links)
-                .map(rel => '<' + links[rel] + '>; rel="' + rel + '"')
-                .join(', '));
-        return this;
-    }
-    location(url) {
-        let loc = url;
-        // "back" is an alias for the referrer
-        if (url === 'back')
-            loc = this.req?.get('Referrer') || '/';
-        // set location
-        return this.setHeader('Location', encodeUrl(loc));
-    }
-    redirect(arg0, arg1) {
-        const address = String(arg1 || arg0);
-        const status = typeof arg0 === 'number' ? arg0 : 302;
-        // Set location header
-        this.location(address);
-        // Respond
-        this.statusCode = status;
-        this.end();
-    }
-    send(body) {
-        let chunk = body;
-        let encoding;
-        const req = this.req;
-        let ctype = toString(this.getHeader('Content-Type'));
-        if (typeof chunk !== 'string') {
-            if (chunk === null)
-                chunk = '';
-            else if (Buffer.isBuffer(chunk)) {
-                if (!ctype)
-                    this.contentType('bin');
-            }
-            else {
-                ctype = 'json';
-                chunk = JSON.stringify(chunk);
-            }
-        }
-        // write strings in utf-8
-        if (typeof chunk === 'string') {
-            encoding = 'utf-8';
-            this.setHeader('Content-Type', setCharset(ctype || 'txt', encoding));
-        }
-        // populate Content-Length
-        let len = 0;
-        if (chunk !== undefined) {
-            if (Buffer.isBuffer(chunk)) {
-                // get length of Buffer
-                len = chunk.length;
-            }
-            else if (chunk.length < 1000) {
-                // just calculate length when small chunk
-                len = Buffer.byteLength(chunk, encoding);
-            }
-            else {
-                // convert chunk to Buffer and calculate
-                chunk = Buffer.from(chunk, encoding);
-                encoding = undefined;
-                len = chunk.length;
-            }
-            this.setHeader('Content-Length', len);
-        }
-        // freshness
-        if (req?.fresh)
-            this.statusCode = 304;
-        // strip irrelevant headers
-        if (this.statusCode === 204 || this.statusCode === 304) {
-            this.removeHeader('Content-Type');
-            this.removeHeader('Content-Length');
-            this.removeHeader('Transfer-Encoding');
-            chunk = '';
-        }
-        // alter headers for 205
-        if (this.statusCode === 205) {
-            this.setHeader('Content-Length', '0');
-            this.removeHeader('Transfer-Encoding');
-            chunk = '';
-        }
-        if (req?.method === 'HEAD') {
-            // skip body for HEAD
-            this.end();
-        }
-        else {
-            // respond
-            if (encoding)
-                this.end(chunk, encoding);
-            else
-                this.end(chunk);
-        }
-        return this;
-    }
-    vary(field) {
-        vary(this, field);
-        return this;
-    }
-}
-function setCharset(type, charset) {
-    if (!(type && charset))
-        return type;
-    // parse type
-    const parsed = contentType.parse(type);
-    // set charset
-    parsed.parameters.charset = charset;
-    // format type
-    return contentType.format(parsed);
-}

package/esm/http/impl/multipart-reader.js

@@ -1,191 +0,0 @@
-import { randomFillSync } from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import nodePath from 'node:path';
-import typeIs from '@browsery/type-is';
-import { BadRequestError } from '@opra/common';
-import busboy from 'busboy';
-import { EventEmitter } from 'events';
-import fsPromise from 'fs/promises';
-import { isNotNullish } from 'valgen';
-export class MultipartReader extends EventEmitter {
-    constructor(context, options, mediaType) {
-        super();
-        this.context = context;
-        this.mediaType = mediaType;
-        this._started = false;
-        this._finished = false;
-        this._cancelled = false;
-        this._items = [];
-        this._stack = [];
-        this.setMaxListeners(1000);
-        this.tempDirectory = options?.tempDirectory || os.tmpdir();
-        const { request } = context;
-        const form = busboy({ headers: request.headers });
-        this._form = form;
-        form.once('error', (e) => {
-            this._cancelled = true;
-            this._finished = true;
-            if (this.listenerCount('error') > 0)
-                this.emit('error', e);
-        });
-        form.on('close', () => {
-            this._finished = true;
-        });
-        form.on('field', (field, value, info) => {
-            const item = {
-                kind: 'field',
-                field,
-                value,
-                mimeType: info.mimeType,
-                encoding: info.encoding,
-            };
-            this._items.push(item);
-            this._stack.push(item);
-            this.emit('field', item);
-            this.emit('item', item);
-        });
-        form.on('file', (field, file, info) => {
-            const saveTo = nodePath.join(this.tempDirectory, `opra-${generateFileName()}`);
-            file.pipe(fs.createWriteStream(saveTo));
-            file.once('end', () => {
-                const item = {
-                    kind: 'file',
-                    field,
-                    storedPath: saveTo,
-                    filename: info.filename,
-                    mimeType: info.mimeType,
-                    encoding: info.encoding,
-                };
-                this._items.push(item);
-                this._stack.push(item);
-                this.emit('file', item);
-                this.emit('item', item);
-            });
-        });
-    }
-    get items() {
-        return this._items;
-    }
-    async getNext() {
-        let item = this._stack.shift();
-        if (!item && !this._finished) {
-            this.resume();
-            item = await new Promise((resolve, reject) => {
-                let resolved = false;
-                if (this._stack.length)
-                    return resolve(this._stack.shift());
-                if (this._form.ended)
-                    return resolve(undefined);
-                this._form.once('close', () => {
-                    if (resolved)
-                        return;
-                    resolved = true;
-                    resolve(this._stack.shift());
-                });
-                this.once('item', () => {
-                    this.pause();
-                    if (resolved)
-                        return;
-                    resolved = true;
-                    resolve(this._stack.shift());
-                });
-                this.once('error', e => reject(e));
-            });
-        }
-        if (item && this.mediaType) {
-            const field = this.mediaType.findMultipartField(item.field);
-            if (!field)
-                throw new BadRequestError(`Unknown multipart field (${item.field})`);
-            if (item.kind === 'field') {
-                const decode = field.generateCodec('decode', { ignoreReadonlyFields: true, projection: '*' });
-                item.value = decode(item.value, {
-                    onFail: issue => `Multipart field (${item.field}) validation failed: ` + issue.message,
-                });
-            }
-            else if (item.kind === 'file') {
-                if (field.contentType) {
-                    const arr = Array.isArray(field.contentType) ? field.contentType : [field.contentType];
-                    if (!(item.mimeType && arr.find(ct => typeIs.is(item.mimeType, [ct])))) {
-                        throw new BadRequestError(`Multipart field (${item.field}) do not accept this content type`);
-                    }
-                }
-            }
-        }
-        /** if all items received we check for required items */
-        if (this._finished && this.mediaType && this.mediaType.multipartFields?.length > 0) {
-            const fieldsLeft = new Set(this.mediaType.multipartFields);
-            for (const x of this._items) {
-                const field = this.mediaType.findMultipartField(x.field);
-                if (field)
-                    fieldsLeft.delete(field);
-            }
-            let issues;
-            for (const field of fieldsLeft) {
-                if (!field.required)
-                    continue;
-                try {
-                    isNotNullish(null, { onFail: () => `Multi part field "${String(field.fieldName)}" is required` });
-                }
-                catch (e) {
-                    if (!issues) {
-                        issues = e.issues;
-                        this.context.errors.push(e);
-                    }
-                    else
-                        issues.push(...e.issues);
-                }
-            }
-            if (this.context.errors.length)
-                throw this.context.errors[0];
-        }
-        return item;
-    }
-    async getAll() {
-        const items = [...this._items];
-        let item;
-        while (!this._cancelled && (item = await this.getNext())) {
-            items.push(item);
-        }
-        return items;
-    }
-    getAll_() {
-        if (this._form.ended)
-            return Promise.resolve([...this._items]);
-        this.resume();
-        return new Promise((resolve, reject) => {
-            this._form.once('error', reject);
-            this._form.once('end', () => {
-                resolve([...this._items]);
-            });
-        });
-    }
-    cancel() {
-        this._cancelled = true;
-        if (this._form.req)
-            this.resume();
-    }
-    resume() {
-        if (!this._started) {
-            this._started = true;
-            this.context.request.pipe(this._form);
-        }
-        this.context.request.resume();
-    }
-    pause() {
-        this.context.request.pause();
-    }
-    async purge() {
-        const promises = [];
-        this._items.forEach(item => {
-            if (item.kind !== 'file')
-                return;
-            promises.push(fsPromise.unlink(item.storedPath));
-        });
-        return Promise.allSettled(promises);
-    }
-}
-function generateFileName() {
-    const buf = Buffer.alloc(10);
-    return new Date().toISOString().substring(0, 10).replace(/-/g, '') + randomFillSync(buf).toString('hex');
-}

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

@@ -1,105 +0,0 @@
-import { isAsyncIterable, isIterable } from '@opra/common';
-import { Duplex, Readable } from 'stream';
-import { convertToHeaders, convertToHeadersDistinct } from '../utils/convert-to-headers.js';
-import { convertToRawHeaders } from '../utils/convert-to-raw-headers.js';
-export const CRLF = Buffer.from('\r\n');
-export const kHeaders = Symbol.for('kHeaders');
-export const kHeadersDistinct = Symbol.for('kHeadersDistinct');
-export const kTrailers = Symbol.for('kTrailers');
-export const kTrailersDistinct = Symbol.for('kTrailersDistinct');
-export const kHttpParser = Symbol.for('kHttpParser');
-/**
- *
- * @class NodeIncomingMessageHost
- */
-export class NodeIncomingMessageHost extends 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 : convertToRawHeaders(init.headers);
-            }
-            if (init.trailers) {
-                this.rawTrailers = Array.isArray(init.trailers) ? init.trailers : 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);
-            if (init.params)
-                this.params = init.params;
-            if (init.cookies)
-                this.cookies = init.cookies;
-        }
-    }
-    get httpVersion() {
-        return this.httpVersionMajor ? this.httpVersionMajor + '.' + this.httpVersionMinor : '';
-    }
-    get headers() {
-        if (!this[kHeaders])
-            this[kHeaders] = convertToHeaders(this.rawHeaders, {}, this.joinDuplicateHeaders);
-        return this[kHeaders];
-    }
-    set headers(headers) {
-        this[kHeaders] = headers;
-    }
-    get headersDistinct() {
-        if (!this[kHeadersDistinct])
-            this[kHeadersDistinct] = convertToHeadersDistinct(this.rawHeaders, {});
-        return this[kHeadersDistinct];
-    }
-    get trailers() {
-        if (!this[kTrailers])
-            this[kTrailers] = convertToHeaders(this.rawTrailers, {}, this.joinDuplicateHeaders);
-        return this[kTrailers];
-    }
-    set trailers(trailers) {
-        this[kTrailers] = trailers;
-    }
-    get trailersDistinct() {
-        if (!this[kTrailersDistinct])
-            this[kTrailersDistinct] = convertToHeadersDistinct(this.rawTrailers, {});
-        return this[kTrailersDistinct];
-    }
-    _read(size) {
-        if (!this.body) {
-            this.push(null);
-            return;
-        }
-        if (!this._readStream) {
-            if (isIterable(this.body) || isAsyncIterable(this.body))
-                this._readStream = Readable.from(this.body);
-            else if (typeof this.body === 'string') {
-                this._readStream = Readable.from(Buffer.from(this.body, 'utf-8'));
-            }
-            else
-                this._readStream = Readable.from(Buffer.from(JSON.stringify(this.body), 'utf-8'));
-        }
-        const chunk = this._readStream.read(size);
-        this.push(chunk);
-    }
-    _write(chunk, encoding, callback) {
-        const error = this[kHttpParser]?.execute(chunk);
-        if (error && typeof error === 'object')
-            callback(error);
-        else
-            callback();
-    }
-}