webhoster 0.1.0 → 0.3.0

package/middleware/CORSMiddleware.js

@@ -1,7 +1,5 @@
 /** @typedef {import('../types').IMiddleware} IMiddleware */
 /** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
 /** @typedef {import('../types').RequestMethod} RequestMethod */
 
 /**
@@ -15,14 +13,13 @@
  * Indicates which methods are supported by the response’s URL for the purposes of the CORS protocol.
  * @prop {string[]} [allowHeaders]
  * Indicates which headers are supported by the response’s URL for the purposes of the CORS protocol.
- * @prop {number} [maxAge]
+ * @prop {number} [maxAge=5]
  * Indicates the number of seconds (5 by default) the information provided by the
  * `Access-Control-Allow-Methods` and `Access-Control-Allow-Headers` headers can be cached.
  * @prop {string[]} [exposeHeaders]
  * Indicates which headers can be exposed as part of the response by listing their names.
  */
 
-/** @implements {IMiddleware} */
 export default class CORSMiddleware {
   /** @param {CORSMiddlewareOptions} [options] */
   constructor(options = {}) {
@@ -34,66 +31,67 @@ export default class CORSMiddleware {
     this.exposeHeaders = options.exposeHeaders;
   }
 
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
-    if (('origin' in req.headers) === false) {
-    // not CORS
-      return 'continue';
+  static OK_BUFFER = Buffer.from('OK', 'ascii');
+
+  static ACCESS_CONTROL_ALLOW_HEADERS_ALL = [
+    'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'CONNECT', 'TRACE', 'PATCH',
+  ].join(',');
+
+  /** @type {MiddlewareFunction} */
+  execute({ request, response }) {
+    if (('origin' in request.headers) === false) {
+      // not CORS
+      return true; // CONTINUE
     }
+
+    // CORS Request
     if (!this.allowOrigin) {
-    // Unspecified default of '*'
-      res.headers['access-control-allow-origin'] = '*';
+      // Unspecified default of '*'
+      response.headers['access-control-allow-origin'] = '*';
     } else {
-      this.allowOrigin.some((origin) => {
+      for (const origin of this.allowOrigin) {
         if (origin === '*') {
-          res.headers['access-control-allow-origin'] = '*';
-          return true;
+          response.headers['access-control-allow-origin'] = '*';
+          break;
         }
         if (typeof origin === 'string') {
-          if (req.headers.origin?.toLowerCase() === origin.toLowerCase()) {
-            res.headers['access-control-allow-origin'] = req.headers.origin;
-            return true;
+          if (request.headers.origin?.toLowerCase() === origin.toLowerCase()) {
+            response.headers['access-control-allow-origin'] = request.headers.origin;
+            break;
           }
-          return false;
+        } else if (origin.test(request.headers.origin)) {
+          response.headers['access-control-allow-origin'] = request.headers.origin;
+          break;
         }
-        if (origin.test(req.headers.origin)) {
-          res.headers['access-control-allow-origin'] = req.headers.origin;
-          return true;
-        }
-        return false;
-      });
+      }
     }
+
     if (this.allowCredentials) {
-      res.headers['access-control-allow-credentials'] = 'true';
+      response.headers['access-control-allow-credentials'] = 'true';
     }
-    if (req.method === 'OPTIONS') {
-      if (this.allowMethods) {
-        res.headers['access-control-allow-methods'] = this.allowMethods.join(',');
-      } else {
-        res.headers['access-control-allow-methods'] = [
-          'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'CONNECT', 'TRACE', 'PATCH',
-        ].join(',');
-      }
-      if (this.allowHeaders) {
-        res.headers['access-control-allow-headers'] = this.allowHeaders.join(',');
-      } else {
-        res.headers['access-control-allow-headers'] = req.headers['access-control-request-headers'];
-      }
+
+    if (request.method === 'OPTIONS') {
+      response.headers['access-control-allow-methods'] = this.allowMethods
+        ? this.allowMethods.join(',')
+        : CORSMiddleware.ACCESS_CONTROL_ALLOW_HEADERS_ALL;
+      response.headers['access-control-allow-headers'] = this.allowHeaders
+        ? this.allowHeaders.join(',')
+        : request.headers['access-control-request-headers'];
       if (this.maxAge != null) {
-        res.headers['access-control-max-age'] = this.maxAge.toString(10);
+        response.headers['access-control-max-age'] = this.maxAge.toString(10);
       }
       // 200 instead of 204 for compatibility
-      res.status = 200;
-      res.stream.end('OK');
-      return 'end';
+      // Manual handling for faster response
+      response.status = 200;
+      response.headers['content-length'] = '0';
+      response.sendHeaders(true, true);
+      return 0; // END
     }
 
+    // Non-CORS-preflight request
     if (this.exposeHeaders) {
-      res.headers['access-control-expose-headers'] = this.exposeHeaders.join(',');
+      response.headers['access-control-expose-headers'] = this.exposeHeaders.join(',');
     }
-    return 'continue';
+    return true; // CONTINUE
   }
 }

package/middleware/CaseInsensitiveHeadersMiddleware.js

@@ -1,8 +1,7 @@
 import CaseInsensitiveObject from '../utils/CaseInsensitiveObject.js';
 
 /** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
+/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
 
 /**
  * @typedef {Object} CaseInsensitiveHeadersMiddlewareOptions
@@ -10,7 +9,6 @@ import CaseInsensitiveObject from '../utils/CaseInsensitiveObject.js';
  * @prop {boolean} [response=false] Mutate response headers to be case-insensistive
  */
 
-/** @implements {IMiddleware} */
 export default class CaseInsensitiveHeadersMiddleware {
   /** @param {CaseInsensitiveHeadersMiddlewareOptions} options */
   constructor(options) {
@@ -18,19 +16,15 @@ export default class CaseInsensitiveHeadersMiddleware {
     this.response = options.response === true;
   }
 
-  /**
-   * @param {!MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
+  /** @type {MiddlewareFunction} */
+  execute({ request, response }) {
     if (this.request) {
     // @ts-ignore Coerce
-      req.headers = new CaseInsensitiveObject(req.headers || {});
+      request.headers = new CaseInsensitiveObject(request.headers || {});
     }
     if (this.response) {
     // @ts-ignore Coerce
-      res.headers = new CaseInsensitiveObject(res.headers || {});
+      response.headers = new CaseInsensitiveObject(response.headers || {});
     }
-    return 'continue';
   }
 }

package/middleware/ContentDecoderMiddleware.js

@@ -1,10 +1,9 @@
-import { PassThrough, Transform } from 'stream';
-import { createBrotliDecompress, createGunzip, createInflate } from 'zlib';
+import { Transform } from 'node:stream';
+import {
+  BrotliDecompress, Gunzip, Inflate,
+} from 'node:zlib';
 
-/** @typedef {import('../types').IMiddleware} IMiddleware */
 /** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
 
 /**
  * @typedef ContentDecoderMiddlewareOptions
@@ -12,10 +11,11 @@ import { createBrotliDecompress, createGunzip, createInflate } from 'zlib';
  * @prop {boolean} [respondNotAcceptable=false]
  */
 
+const CONTINUE = true;
+
 /**
  * Implements `Accept-Encoding`
  * https://tools.ietf.org/html/rfc7231#section-5.3.4
- * @implements {IMiddleware}
  */
 export default class ContentDecoderMiddleware {
   /** @param {ContentDecoderMiddlewareOptions} [options] */
@@ -24,68 +24,114 @@ export default class ContentDecoderMiddleware {
     this.respondNotAcceptable = options.respondNotAcceptable === true;
   }
 
-  /**
-   * @param {!MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req, res }) {
-    switch (req.method) {
+  /** @type {MiddlewareFunction} */
+  execute({ request, response }) {
+    switch (request.method) {
       case 'HEAD':
       case 'GET':
-        return 'continue';
+        return CONTINUE;
       default:
     }
 
-    res.headers['accept-encoding'] = 'gzip, deflate, br';
-    const contentEncoding = (req.headers['content-encoding'] ?? '').trim().toLowerCase();
+    // TODO: Use transforms
+
+    response.headers['accept-encoding'] = 'gzip, deflate, br';
+    const contentEncoding = request.headers['content-encoding'];
+    if (!contentEncoding) return CONTINUE;
 
-    switch (contentEncoding) {
+    switch (contentEncoding.trim().toLowerCase()) {
       case '':
       case 'identity':
-        return 'continue';
+        return CONTINUE;
       case 'gzip':
       case 'br':
       case 'deflate':
         break;
       default:
         if (this.respondNotAcceptable) {
-          res.status = 406;
-          return 'end';
+          return 406;
         }
-        return 'continue';
+        return CONTINUE;
     }
 
-    const source = req.stream;
+    /** @type {import('stream').Readable} */
+    let inputStream;
+
+    // Don't built gZipStream until a read request is made
+    // By default, newDownstream <= inputStream
+    // On first read, newDownstream <= gZipStream <= inputStream
+    // Read request is intercepted by newDownstream
+
+    /** @type {import("zlib").Gunzip} */
+    let gzipStream;
     let initialized = false;
-    const { chunkSize } = this;
-    const newReadable = new PassThrough({
-      read(...args) {
+
+    const gzipOptions = { chunkSize: this.chunkSize };
+    const newDownstream = new Transform({
+
+      read: (...args) => {
         if (!initialized) {
-        /** @type {import("zlib").Gzip} */
-          let gzipStream;
+          /** @type {import("zlib").Gzip} */
           switch (contentEncoding) {
             case 'deflate':
-              gzipStream = createInflate({ chunkSize });
+              gzipStream = new Inflate(gzipOptions);
               break;
             case 'gzip':
-              gzipStream = createGunzip({ chunkSize });
+              gzipStream = new Gunzip(gzipOptions);
               break;
             case 'br':
-              gzipStream = createBrotliDecompress({ chunkSize });
+              gzipStream = new BrotliDecompress(gzipOptions);
               break;
             default:
               throw new Error('UNKNOWN_ENCODING');
           }
-          source.pipe(gzipStream).pipe(this);
+          // From newDownstream <= inputStream
+          // To newDownstream <= gzipStream < =inputStream
+
+          // Forward errors
+          gzipStream.on('error', (err) => inputStream.emit('error', err));
+          gzipStream.on('data', (chunk) => newDownstream.push(chunk));
+
+          inputStream.on('end', () => gzipStream.end());
+          gzipStream.on('end', () => {
+            newDownstream.push(null);
+            if (newDownstream.readable) {
+              newDownstream.end();
+            }
+          });
+
+          if (inputStream.pause()) inputStream.resume();
           initialized = true;
         }
-        if (source.isPaused()) source.resume();
-        // eslint-disable-next-line no-underscore-dangle
+
         Transform.prototype._read.call(this, ...args);
       },
+      transform: (chunk, chunkEncoding, callback) => {
+        gzipStream.write(chunk, (err) => {
+          if (err) console.error(err);
+          callback(err);
+        });
+      },
+      flush: (callback) => {
+        if (gzipStream) {
+          gzipStream.flush(() => {
+            callback();
+          });
+        }
+      },
+      final: (callback) => {
+        if (gzipStream) {
+          gzipStream.end();
+          gzipStream.flush(() => {
+            callback();
+          });
+        }
+      },
     });
-    source.pause();
-    req.replaceStream(newReadable);
-    return 'continue';
+
+    newDownstream.tag = 'ContentDecoder';
+    inputStream = request.addDownstream(newDownstream, { autoPause: true });
+
+    return CONTINUE;
   }
 }