@opra/core 0.33.13 → 1.0.0-alpha.10

package/esm/http/{http-server-response.js → impl/http-outgoing.host.js}

@@ -2,6 +2,7 @@
   Some parts of this file contains codes from open source express library
   https://github.com/expressjs
  */
+import { HttpStatusCode } from '@opra/common';
 import contentDisposition from 'content-disposition';
 import contentType from 'content-type';
 import cookie from 'cookie';
@@ -11,23 +12,8 @@ import mime from 'mime-types';
 import path from 'path';
 import { toString } from 'putil-varhelpers';
 import vary from 'vary';
-import { HttpStatusCode, isStream, mergePrototype } from '@opra/common';
-import { HttpOutgoingMessageHost } from './impl/http-outgoing-message.host.js';
 const charsetRegExp = /;\s*charset\s*=/;
-function isHttpIncomingMessage(v) {
-    return v && typeof v.getHeaders === 'function' && isStream(v);
-}
-export var HttpServerResponse;
-(function (HttpServerResponse) {
-    function from(instance) {
-        if (!isHttpIncomingMessage(instance))
-            instance = new HttpOutgoingMessageHost(instance);
-        mergePrototype(instance, HttpServerResponseHost.prototype);
-        return instance;
-    }
-    HttpServerResponse.from = from;
-})(HttpServerResponse || (HttpServerResponse = {}));
-class HttpServerResponseHost {
+export class HttpOutgoingHost {
     attachment(filename) {
         if (filename)
             this.contentType(path.extname(filename));
@@ -35,9 +21,7 @@ class HttpServerResponseHost {
         return this;
     }
     contentType(type) {
-        const ct = type.indexOf('/') === -1
-            ? mime.lookup(type)
-            : type;
+        const ct = type.indexOf('/') === -1 ? mime.lookup(type) : type;
         this.setHeader('Content-Type', ct);
         return this;
     }
@@ -50,9 +34,7 @@ class HttpServerResponseHost {
             return this;
         }
         const fieldLower = field.toLowerCase();
-        let value = Array.isArray(val)
-            ? val.map(String)
-            : (val ? String(val) : '');
+        let value = Array.isArray(val) ? val.map(String) : val ? String(val) : '';
         // add charset to content-type
         if (fieldLower === 'content-type') {
             if (Array.isArray(value)) {
@@ -71,15 +53,13 @@ class HttpServerResponseHost {
         const opts = {
             expires: new Date(1),
             path: '/',
-            ...options
+            ...options,
         };
         return this.cookie(name, '', opts);
     }
     cookie(name, value, options) {
         const opts = { ...options };
-        let val = typeof value === 'object'
-            ? 'j:' + JSON.stringify(value)
-            : String(value);
+        let val = typeof value === 'object' ? 'j:' + JSON.stringify(value) : String(value);
         if (opts.signed) {
             const secret = opts.secret || this.req?.secret;
             if (!secret)
@@ -180,7 +160,7 @@ class HttpServerResponseHost {
         if (req?.fresh)
             this.statusCode = 304;
         // strip irrelevant headers
-        if (204 === this.statusCode || 304 === this.statusCode) {
+        if (this.statusCode === 204 || this.statusCode === 304) {
             this.removeHeader('Content-Type');
             this.removeHeader('Content-Length');
             this.removeHeader('Transfer-Encoding');

package/esm/http/{helpers/multipart-helper.js → impl/multipart-reader.js}

@@ -1,34 +1,36 @@
 import { EventEmitter } from 'events';
 import formidable from 'formidable';
 import fs from 'fs/promises';
-export class MultipartIterator extends EventEmitter {
-    constructor(options) {
+export class MultipartReader extends EventEmitter {
+    constructor(incoming, options) {
         super();
+        this._started = false;
         this._cancelled = false;
         this._items = [];
         this._stack = [];
         this.setMaxListeners(1000);
-        const form = this._form = formidable({
+        this._incoming = incoming;
+        const form = (this._form = formidable({
             ...options,
-            filter: (part) => {
-                return !this._cancelled && (!options?.filter || options.filter(part));
-            }
-        });
+            filter: (part) => !this._cancelled && (!options?.filter || options.filter(part)),
+        }));
         form.once('error', () => {
             this._cancelled = true;
             if (this.listenerCount('error') > 0)
                 this.emit('error');
         });
-        form.on('field', (field, value) => {
-            const item = { field, value };
+        form.on('field', (fieldName, value) => {
+            const item = { fieldName, type: 'field', value };
             this._items.push(item);
             this._stack.push(item);
+            this.emit('field', item);
             this.emit('item', item);
         });
-        form.on('file', (field, file) => {
-            const item = { field, file };
+        form.on('file', (fieldName, file) => {
+            const item = { fieldName, type: 'file', file };
             this._items.push(item);
             this._stack.push(item);
+            this.emit('file', item);
             this.emit('item', item);
         });
     }
@@ -44,7 +46,7 @@ export class MultipartIterator extends EventEmitter {
             if (this._form.ended)
                 return resolve(undefined);
             this.once('item', () => resolve(this._stack.shift()));
-            this.once('error', (e) => reject(e));
+            this.once('error', e => reject(e));
         });
     }
     getAll() {
@@ -64,6 +66,8 @@ export class MultipartIterator extends EventEmitter {
             this.resume();
     }
     resume() {
+        if (!this._started)
+            this._form.parse(this._incoming, () => undefined);
         if (this._form.req)
             this._form.resume();
     }
@@ -71,10 +75,9 @@ export class MultipartIterator extends EventEmitter {
         if (this._form.req)
             this._form.pause();
     }
-    async deleteFiles() {
+    async deleteTempFiles() {
         const promises = [];
-        this._items
-            .forEach(item => {
+        this._items.forEach(item => {
             if (!item.file)
                 return;
             const file = item.file;
@@ -82,17 +85,10 @@ export class MultipartIterator extends EventEmitter {
                 if (file._writeStream.closed)
                     return resolve();
                 file._writeStream.once('close', resolve);
-            }).then(() => {
-                return fs.unlink(file.filepath);
-            }).then(() => {
-                return 0;
-            }));
+            })
+                .then(() => fs.unlink(file.filepath))
+                .then(() => 0));
         });
         return Promise.allSettled(promises);
     }
-    static async create(incoming, options) {
-        const out = new MultipartIterator(options);
-        await out._form.parse(incoming);
-        return out;
-    }
 }

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

@@ -1,23 +1,18 @@
-/*
-  This file contains code blocks from open source NodeJs project
-  https://github.com/nodejs/
- */
-import { Duplex, Readable } from 'stream';
-import { HTTPParser } from '@browsery/http-parser';
 import { isAsyncIterable, isIterable } from '@opra/common';
-import { concatReadable } from '../helpers/concat-readable.js';
-import { convertToHeaders, convertToHeadersDistinct } from '../helpers/convert-to-headers.js';
-import { convertToRawHeaders } from '../helpers/convert-to-raw-headers.js';
+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 HttpIncomingMessageHost
+ * @class NodeIncomingMessageHost
  */
-export class HttpIncomingMessageHost extends Duplex {
+export class NodeIncomingMessageHost extends Duplex {
     constructor(init) {
         super();
         this.rawHeaders = [];
@@ -38,20 +33,24 @@ export class HttpIncomingMessageHost extends Duplex {
                 else
                     this.body = Buffer.from(JSON.stringify(init.body), 'utf-8');
             }
-            if (init.headers)
+            if (init.headers) {
                 this.rawHeaders = Array.isArray(init.headers) ? init.headers : convertToRawHeaders(init.headers);
-            if (init.trailers)
+            }
+            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
-            : '';
+        return this.httpVersionMajor ? this.httpVersionMajor + '.' + this.httpVersionMinor : '';
     }
     get headers() {
         if (!this[kHeaders])
@@ -95,50 +94,12 @@ export class HttpIncomingMessageHost extends Duplex {
         }
         const chunk = this._readStream.read(size);
         this.push(chunk);
-        // this.push(null);s
     }
     _write(chunk, encoding, callback) {
-        const error = this._httpParser?.execute(chunk);
+        const error = this[kHttpParser]?.execute(chunk);
         if (error && typeof error === 'object')
             callback(error);
         else
             callback();
     }
-    static from(iterable) {
-        if (typeof iterable === 'object' && !(isIterable(iterable) || isAsyncIterable(iterable)))
-            return new HttpIncomingMessageHost(iterable);
-        const msg = new HttpIncomingMessageHost();
-        const parser = msg._httpParser = 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;
-        };
-        parser[HTTPParser.kOnHeaders] = (trailers) => {
-            msg.rawTrailers = trailers;
-        };
-        parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
-            bodyChunks = bodyChunks || [];
-            bodyChunks.push(chunk.subarray(offset, offset + length));
-        };
-        parser[HTTPParser.kOnMessageComplete] = () => {
-            msg.complete = true;
-            if (bodyChunks)
-                msg.body = Buffer.concat(bodyChunks);
-        };
-        const readable = concatReadable(Readable.from(iterable), Readable.from(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));
-        });
-    }
 }

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

@@ -3,15 +3,15 @@
   https://github.com/nodejs/
  */
 import { Duplex } from 'stream';
-import { validateHeaderName, validateHeaderValue, validateString } from '../helpers/common.js';
+import { validateHeaderName, validateHeaderValue, validateString } from '../utils/common.js';
 export const kOutHeaders = Symbol.for('kOutHeaders');
 export const kOutTrailers = Symbol.for('kOutTrailers');
 // noinspection JSUnusedLocalSymbols
 /**
  *
- * @class HttpOutgoingMessageHost
+ * @class NodeOutgoingMessageHost
  */
-export class HttpOutgoingMessageHost extends Duplex {
+export class NodeOutgoingMessageHost extends Duplex {
     constructor(init) {
         super();
         this._headersSent = false;
@@ -64,8 +64,7 @@ export class HttpOutgoingMessageHost extends Duplex {
     }
     addTrailers(headers) {
         if (headers && typeof headers === 'object') {
-            const entries = typeof headers.entries === 'function'
-                ? headers.entries() : Object.entries(headers);
+            const entries = typeof headers.entries === 'function' ? headers.entries() : Object.entries(headers);
             let trailers = this[kOutTrailers];
             if (trailers == null)
                 this[kOutTrailers] = trailers = { __proto__: null };
@@ -78,6 +77,9 @@ export class HttpOutgoingMessageHost extends Duplex {
         }
         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`);
@@ -93,8 +95,7 @@ export class HttpOutgoingMessageHost extends Duplex {
         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);
+            const entries = typeof headers.entries === 'function' ? headers.entries() : Object.entries(headers);
             for (const entry of entries) {
                 this.setHeader(entry[0], entry[1]);
             }
@@ -142,8 +143,7 @@ export class HttpOutgoingMessageHost extends Duplex {
     }
     hasHeader(name) {
         validateString(name);
-        return this[kOutHeaders] != null &&
-            !!this[kOutHeaders][name.toLowerCase()];
+        return this[kOutHeaders] != null && !!this[kOutHeaders][name.toLowerCase()];
     }
     removeHeader(name) {
         validateString(name);
@@ -188,7 +188,4 @@ export class HttpOutgoingMessageHost extends Duplex {
         //
         return this;
     }
-    static from(init) {
-        return new HttpOutgoingMessageHost(init);
-    }
 }

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,12 @@
+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 = {}));