webhoster 0.1.0 → 0.3.0

package/middleware/SendJsonMiddleware.js

@@ -0,0 +1,131 @@
+/** @typedef {import('../types').IMiddleware} IMiddleware */
+/** @typedef {import('../types').MiddlewareResponseFunction} MiddlewareResponseFunction */
+/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../types/index.js').ResponseFinalizer} ResponseFinalizer */
+
+/**
+ * @typedef {Object} SendJsonMiddlewareOptions
+ * @prop {string} [defaultCharset='utf-8']
+ * @prop {boolean} [setCharset=true]
+ * Automatically applies charset in `Content-Type`
+ * @prop {boolean} [setMediaType=true]
+ * Automatically applies `application/json` mediatype in `Content-Type`
+ */
+
+/* eslint-disable unicorn/text-encoding-identifier-case */
+
+export default class SendJsonMiddleware {
+  /** @type {SendJsonMiddleware} */
+  static #defaultInstance;
+
+  /**
+   * @param {string} charset
+   * @return {BufferEncoding}
+   */
+  static charsetAsBufferEncoding(charset) {
+    switch (charset) {
+      case 'iso-8859-1':
+      case 'ascii':
+      case 'binary':
+      case 'latin1':
+        return 'latin1';
+      case 'utf-16le':
+      case 'ucs-2':
+      case 'ucs2':
+      case 'utf16le':
+        return 'utf16le';
+      case 'base64':
+      case 'hex':
+        return /** @type {BufferEncoding} */ (charset);
+      case 'utf-8':
+      case 'utf8':
+      default:
+        return 'utf-8';
+    }
+  }
+
+  /** @type {MiddlewareResponseFunction} */
+  static Execute({ response }) {
+    if (!SendJsonMiddleware.#defaultInstance) {
+      SendJsonMiddleware.#defaultInstance = new SendJsonMiddleware({
+        defaultCharset: 'utf-8',
+        setCharset: true,
+        setMediaType: true,
+      });
+    }
+    response.finalizers.push(SendJsonMiddleware.#defaultInstance.finalizeResponse);
+  }
+
+  /** @param {SendJsonMiddlewareOptions} [options] */
+  constructor(options = {}) {
+    this.options = {
+      defaultCharset: options.defaultCharset || 'utf-8',
+      setCharset: options.setCharset !== false,
+      setMediaType: options.setMediaType !== false,
+    };
+    // Single shared function instead of one per response
+    this.finalizeResponse = this.finalizeResponse.bind(this);
+  }
+
+  /** @type {ResponseFinalizer} */
+  finalizeResponse(response) {
+    if (response.isStreaming
+      || response.body == null
+      || typeof response.body !== 'object'
+      || Buffer.isBuffer(response.body)) return;
+
+    // TODO: Check response.request.headers.accepts
+
+    let charset;
+    const contentType = /** @type {string} */ (response.headers['content-type']);
+    if (contentType) {
+      const newDirectives = [];
+      for (const directive of contentType.split(';')) {
+        const [key, value] = directive.split('=');
+        if (key?.trim().toLowerCase() !== 'charset') {
+          newDirectives.push(directive);
+          continue;
+        }
+        charset = value?.trim().toLowerCase();
+        const firstQuote = charset.indexOf('"');
+        const lastQuote = charset.lastIndexOf('"');
+        if (firstQuote !== -1 && lastQuote !== -1) {
+          charset = charset.slice(firstQuote + 1, lastQuote);
+        }
+        break;
+      }
+
+      if (!charset) {
+        charset = this.options.defaultCharset;
+      }
+
+      if (this.options.setCharset && !response.headersSent) {
+        newDirectives.push(`charset=${charset}`);
+        response.headers['content-type'] = newDirectives.join(';');
+      }
+    } else if (this.options.setMediaType) {
+      charset = this.options.defaultCharset;
+      if (!response.headersSent) {
+        response.headers['content-type'] = this.options.setCharset
+          ? `application/json;charset=${charset}`
+          : 'application/json';
+      }
+    } else if (this.options.setCharset) {
+      charset = this.options.defaultCharset;
+      if (!response.headersSent) {
+        response.headers['content-type'] = `;charset=${charset}`;
+      }
+    } else {
+      // noop?
+    }
+
+    const stringData = JSON.stringify(response.body);
+    const bufferEncoding = SendJsonMiddleware.charsetAsBufferEncoding(charset);
+    response.body = Buffer.from(stringData, bufferEncoding);
+  }
+
+  /** @type {MiddlewareResponseFunction} */
+  execute({ response }) {
+    response.finalizers.push(this.finalizeResponse);
+  }
+}

package/middleware/SendStringMiddleware.js

@@ -0,0 +1,87 @@
+/** @typedef {import('../types/index.js').IMiddleware} IMiddleware */
+/** @typedef {import('../types/index.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../types/index.js').ResponseFinalizer} ResponseFinalizer */
+
+/**
+ * @typedef {Object} SendStringMiddlewareOptions
+ * @prop {string} [defaultCharset='utf-8']
+ * @prop {boolean} [setCharset=true]
+ * Automatically applies charset in `Content-Type`
+ */
+
+export default class SendStringMiddleware {
+  /** @param {SendStringMiddlewareOptions} [options] */
+  constructor(options = {}) {
+    this.options = {
+      defaultCharset: options.defaultCharset || 'utf-8',
+      setCharset: options.setCharset !== false,
+    };
+    // Single shared function instead of one per response
+    this.finalizeResponse = this.finalizeResponse.bind(this);
+  }
+
+  /**
+   * @param {string} charset
+   * @return {BufferEncoding}
+   */
+  static charsetAsBufferEncoding(charset) {
+    switch (charset) {
+      case 'iso-8859-1':
+      case 'ascii':
+      case 'binary':
+      case 'latin1':
+        return 'latin1';
+      case 'utf-16le':
+      case 'ucs-2':
+      case 'ucs2':
+      case 'utf16le':
+        return 'utf16le';
+      case 'base64':
+      case 'hex':
+        return /** @type {BufferEncoding} */ (charset);
+      case 'utf-8':
+      case 'utf8':
+      default:
+        return 'utf-8';
+    }
+  }
+
+  /** @type {ResponseFinalizer} */
+  finalizeResponse(response) {
+    if (response.isStreaming || typeof response.body !== 'string') return true;
+    let charset;
+    let contentType = /** @type {string} */ (response.headers['content-type']);
+    if (contentType) {
+      contentType.split(';').some((directive) => {
+        const parameters = directive.split('=');
+        if (parameters[0].trim().toLowerCase() !== 'charset') {
+          return false;
+        }
+        charset = parameters[1]?.trim().toLowerCase();
+        const firstQuote = charset.indexOf('"');
+        const lastQuote = charset.lastIndexOf('"');
+        if (firstQuote !== -1 && lastQuote !== -1) {
+          charset = charset.slice(firstQuote + 1, lastQuote);
+        }
+        return true;
+      });
+    } else {
+      contentType = '';
+    }
+    if (!charset) {
+      charset = this.options.defaultCharset || 'utf-8';
+      if (this.options.setCharset && !response.headersSent) {
+        response.headers['content-type'] = `${contentType || ''};charset=${charset}`;
+      }
+    }
+
+    const bufferEncoding = SendStringMiddleware.charsetAsBufferEncoding(charset);
+    response.body = Buffer.from(response.body, bufferEncoding);
+    return true;
+  }
+
+  /** @type {MiddlewareFunction} */
+  execute({ response }) {
+    response.finalizers.push(this.finalizeResponse);
+  }
+}

package/package.json

@@ -1,5 +1,31 @@
 {
-  "name": "webhoster",
+  "author": "Carlos Lopez Jr. <clshortfuse@gmail.com> (https://shortfuse.org/)",
+  "ava": {
+    "files": [
+      "test/**/*.js",
+      "!test/fixtures/**"
+    ]
+  },
+  "description": "An opt-in, stream-based approach to Web Hosting with NodeJS",
+  "devDependencies": {
+    "@fidm/x509": "^1.2.1",
+    "@types/node": "^16.18.126",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "ava": "^4.3.3",
+    "c8": "^7.14.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-canonical": "^4.18.1",
+    "eslint-plugin-jsdoc": "^46.10.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-unicorn": "^48.0.1"
+  },
+  "engines": {
+    "node": ">v16.13"
+  },
+  "exports": {
+    "./*": "./*"
+  },
   "keywords": [
     "http",
     "http2",
@@ -11,35 +37,18 @@
     "cors",
     "gzip"
   ],
-  "version": "0.1.0",
-  "description": "An opt-in, stream-based approach to Web Hosting with NodeJS",
-  "author": "clshortfuse@gmail.com",
-  "homepage": "https://github.com/clshortfuse/webhoster",
-  "repository": "github:clshortfuse/webhoster",
   "license": "MIT",
-  "main": "index.cjs",
-  "exports": {
-    "./": "./"
-  },
-  "type": "module",
-  "engines": {
-    "node": ">=14"
-  },
+  "name": "webhoster",
   "scripts": {
-    "prepublishOnly": "rollup -c",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "debug-test": "ava --serial",
+    "test": "c8 ava",
+    "pretestallsync": "rimraf coverage",
+    "testallsync": "scripts/test-all-sync.sh",
+    "posttestallsync": "c8 report",
+    "pretestall": "rimraf coverage",
+    "testall": "scripts/test-all.sh",
+    "posttestall": "c8 report"
   },
-  "devDependencies": {
-    "@fidm/x509": "^1.2.1",
-    "@types/node": "^14.0.14",
-    "@types/tedious": "^4.0.1",
-    "babel-eslint": "^10.1.0",
-    "eslint": "^7.3.1",
-    "eslint-config-airbnb-base": "^14.2.0",
-    "eslint-plugin-babel": "^5.3.0",
-    "eslint-plugin-import": "^2.22.0",
-    "eslint-plugin-jsdoc": "^25.4.3",
-    "eslint-plugin-node": "^11.1.0",
-    "rollup": "^2.18.1"
-  }
+  "type": "module",
+  "version": "0.3.0"
 }

package/polyfill/FormData.js

@@ -0,0 +1,164 @@
+/* @see https://xhr.spec.whatwg.org/#dom-formdata */
+
+/** @implements {FormData} */
+export default class FormData {
+  /** @type {Map<string, (string|File)[]>} */
+  #list = new Map();
+
+  /** @param {HTMLFormElement} [form] */
+  constructor(form) {
+    if (form) {
+      throw new Error('InvalidStateError');
+    }
+  }
+
+  /**
+   * @param {string} s
+   * @return {string}
+   */
+  static #scalarValue = String;
+
+  /**
+   * @param {string} name
+   * @param {string|Blob} value
+   * @param {string} [filename]
+   * @return {{name:string, value:string|File}}
+   */
+  static #createEntry(name, value, filename) {
+    if (typeof value === 'string') {
+      return {
+        name: FormData.#scalarValue(name),
+        value: FormData.#scalarValue(value),
+      };
+    }
+
+    if (typeof File === 'undefined') {
+      if (!('name' in value) && !('lastModified' in value)) {
+        /** @type {File} */
+        // eslint-disable-next-line unicorn/prefer-spread
+        const file = Object.defineProperties(value.slice(), {
+          name: {
+            value: filename === undefined ? 'blob' : filename,
+          },
+          lastModified: {
+            value: Date.now(),
+          },
+          toString: { value: () => '[object File]' },
+        });
+        return {
+          name: FormData.#scalarValue(name),
+          value: file,
+        };
+      }
+      return {
+        name: FormData.#scalarValue(name),
+        value,
+      };
+    }
+    if (value instanceof File) {
+      return {
+        name: FormData.#scalarValue(name),
+        value,
+      };
+    }
+    return {
+      name: FormData.#scalarValue(name),
+      value: new File([value], filename === undefined ? 'blob' : filename, {}),
+    };
+  }
+
+  /**
+   * @param {string} name
+   * @param {string|Blob} value
+   * @param {string} [filename]
+   * @return {void}
+   */
+  append(name, value, filename) {
+    const entry = FormData.#createEntry(name, value, filename);
+    console.log(entry);
+    if (this.#list.has(entry.name)) {
+      this.#list.get(entry.name).push(entry.value);
+    } else {
+      this.#list.set(name, [entry.value]);
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @return {void}
+   */
+  delete(name) {
+    this.#list.delete(name);
+  }
+
+  /**
+   * @param {string} name
+   * @return {null|File|string}
+   */
+  get(name) {
+    const entry = this.#list.get(name);
+    if (!entry) return null;
+    return entry[0];
+  }
+
+  /**
+   * @param {string} name
+   * @return {(File|string)[]}
+   */
+  getAll(name) {
+    return this.#list.get(name) ?? [];
+  }
+
+  /**
+   * @param {string} name
+   * @return {boolean}
+   */
+  has(name) {
+    return this.#list.has(name);
+  }
+
+  /**
+   * @param {string} name
+   * @param {string|Blob} value
+   * @param {string} [filename]
+   * @return {void}
+   */
+  set(name, value, filename) {
+    const entry = FormData.#createEntry(name, value, filename);
+    if (this.#list.has(entry.name)) {
+      const entries = this.#list.get(name);
+      entries.splice(0, entries.length, entry.value);
+    } else {
+      this.#list.set(name, [entry.value]);
+    }
+  }
+
+  /**
+   * @param {(value:(string|File), key:string, parent:this) => void} callback
+   * @return {void}
+   */
+  forEach(callback) {
+    for (const [key, value] of this) {
+      callback(value, key, this);
+    }
+  }
+
+  get keys() {
+    return this.#list.keys;
+  }
+
+  * values() {
+    for (const value of this.#list.values()) {
+      yield value[0];
+    }
+  }
+
+  * [Symbol.iterator]() {
+    for (const entry of this.#list.entries()) {
+      yield /** @type {[string, string|File]} */ ([entry[0], entry[1][0]]);
+    }
+  }
+}
+
+FormData.prototype.entries = FormData.prototype[Symbol.iterator];
+FormData.prototype.toString = () => '[Object FormData]';

package/rollup.config.js

@@ -1,4 +1,3 @@
-/* eslint-disable import/no-anonymous-default-export */
 /** @typedef {import('rollup')} */
 export default {
   input: 'index.js',

package/scripts/test-all-sync.sh

@@ -0,0 +1,6 @@
+. ~/.nvm/nvm.sh; 
+nvm install 16.13; nvm use 16.13; npx c8 --clean false -r none ava;
+nvm install 16   ; nvm use 16   ; npx c8 --clean false -r none ava;
+nvm install 18   ; nvm use 18   ; npx c8 --clean false -r none ava;
+nvm install 20   ; nvm use 20   ; npx c8 --clean false -r none ava;
+nvm install 22   ; nvm use 22   ; npx c8 --clean false -r none ava;

package/scripts/test-all.sh

@@ -0,0 +1,7 @@
+echo . \
+  & sh -c ". ~/.nvm/nvm.sh; nvm install 16.13; nvm use 16.13; npx c8 --clean false -r none ava;" \
+  & sh -c ". ~/.nvm/nvm.sh; nvm install 16; nvm use 16; npx c8 --clean false -r none ava;" \
+  & sh -c ". ~/.nvm/nvm.sh; nvm install 18; nvm use 18; npx c8 --clean false -r none ava;" \
+  & sh -c ". ~/.nvm/nvm.sh; nvm install 20; nvm use 20; npx c8 --clean false -r none ava;" \
+  & sh -c ". ~/.nvm/nvm.sh; nvm install 22; nvm use 22; npx c8 --clean false -r none ava;" \
+  

package/templates/starter.js

@@ -0,0 +1,53 @@
+import HttpHandler from '../lib/HttpHandler.js';
+import HttpListener from '../helpers/HttpListener.js';
+import ContentDecoderMiddleware from '../middleware/ContentDecoderMiddleware.js';
+import SendStringMiddleware from '../middleware/SendStringMiddleware.js';
+import SendJsonMiddleware from '../middleware/SendJsonMiddleware.js';
+import ContentEncoderMiddleware from '../middleware/ContentEncoderMiddleware.js';
+import HashMiddleware from '../middleware/HashMiddleware.js';
+import ContentLengthMiddleware from '../middleware/ContentLengthMiddleware.js';
+import AutoHeadersMiddleware from '../middleware/AutoHeadersMiddleware.js';
+import HeadMethodMiddleware from '../middleware/HeadMethodMiddleware.js';
+
+/**
+ * @param {Object} options
+ * @param {string} [options.host='0.0.0.0']
+ * @param {number} [options.port=8080]
+ * @param {import('../types').Middleware[]} [options.middleware]
+ * @param {import('../types').MiddlewareErrorHandler[]} [options.errorHandlers]
+ * @return {Promise<import('../helpers/HttpListener.js').default>}
+ */
+export async function start(options) {
+  HttpHandler.defaultInstance.middleware.push(
+    new ContentDecoderMiddleware(),
+    new SendStringMiddleware(),
+    new SendJsonMiddleware(),
+    new ContentEncoderMiddleware(),
+    new HashMiddleware(),
+    new ContentLengthMiddleware(),
+    new AutoHeadersMiddleware(),
+    new HeadMethodMiddleware(),
+  );
+  if (options.middleware) {
+    // Push by reference to allow post modification
+    HttpHandler.defaultInstance.middleware.push(options.middleware);
+  }
+  if (!options.errorHandlers) {
+    HttpHandler.defaultInstance.errorHandlers.push(
+      {
+        onError() {
+          return 500;
+        },
+      },
+    );
+  }
+
+  HttpListener.defaultInstance.configure({
+    insecureHost: options.host,
+    insecurePort: options.port,
+  });
+
+  await HttpListener.defaultInstance.startHttpServer();
+
+  return HttpListener.defaultInstance;
+}

package/test/fixtures/stream.js

@@ -0,0 +1,68 @@
+import { createHash } from 'node:crypto';
+import {
+  Readable, pipeline as legacyPipeline,
+} from 'node:stream';
+import { promisify } from 'node:util';
+
+/** @type {import('node:stream/promises').pipeline} */
+let pipeline;
+try {
+  ({ pipeline } = (await import('node:stream/promises')));
+} catch {
+  pipeline = promisify(legacyPipeline);
+}
+
+const BUFFER_SIZE = 1024 * 16;
+const CHUNK_SIZE = 256 / 8;
+const CHUNK_COUNT = BUFFER_SIZE / CHUNK_SIZE;
+
+const SEED = Math.floor(Math.random() * (2 ** 4));
+
+/** @yields {Buffer} */
+function* binaryGenerator() {
+  for (let index = 0; index < CHUNK_COUNT; index++) {
+    const number_ = (SEED + index);
+    /* eslint-disable no-bitwise */
+    yield createHash('sha256').update(Buffer.from([
+      (number_ >> 24) & 255,
+      (number_ >> 16) & 255,
+      (number_ >> 8) & 255,
+      number_ & 255,
+    ])).digest();
+    /* eslint-enable no-bitwise */
+  }
+}
+
+/** @yields {Buffer} */
+function* textGenerator() {
+  for (const chunk of binaryGenerator()) {
+    const hexString = chunk.toString('hex');
+    yield Buffer.from(hexString, 'utf-8');
+  }
+}
+
+/** @return {Readable} */
+export function getTestBinaryStream() {
+  return Readable.from(binaryGenerator());
+}
+
+/** @return {Readable} */
+export function getTestTextStream() {
+  return Readable.from(textGenerator());
+}
+
+/** @return {Promise<string>} */
+export async function getTestHash() {
+  const hash = createHash('sha256');
+  await pipeline(binaryGenerator(), hash);
+  return hash.digest().toString('hex');
+}
+
+/** @return {string} */
+export function getTestString() {
+  let data = '';
+  for (const chunk of textGenerator()) {
+    data += chunk;
+  }
+  return data;
+}

package/test/helpers/HttpListener/construct.js

@@ -0,0 +1,18 @@
+import test from 'ava';
+
+import HttpListener from '../../../helpers/HttpListener.js';
+
+test('HttpListener can be constructed with defaults', (t) => {
+  const listener = new HttpListener();
+  t.truthy(listener);
+  t.is(typeof listener.startHttpServer, 'function');
+  t.is(typeof listener.stopHttpServer, 'function');
+});
+
+test('HttpListener.defaultInstance returns a singleton', (t) => {
+  const inst1 = HttpListener.defaultInstance;
+  const inst2 = HttpListener.defaultInstance;
+  t.truthy(inst1);
+  t.is(inst1, inst2);
+  t.true(inst1 instanceof HttpListener);
+});

package/test/helpers/HttpListener/customOptions.js

@@ -0,0 +1,22 @@
+import test from 'ava';
+import HttpListener from '../../../helpers/HttpListener.js';
+
+// Test custom port/host and handler injection
+
+test('custom insecurePort and insecureHost are set', t => {
+  const listener = new HttpListener({ insecurePort: 1234, insecureHost: '127.0.0.1' });
+  t.is(listener.insecurePort, 1234);
+  t.is(listener.insecureHost, '127.0.0.1');
+});
+
+test('custom securePort and secureHost are set', t => {
+  const listener = new HttpListener({ securePort: 4321, secureHost: 'localhost' });
+  t.is(listener.securePort, 4321);
+  t.is(listener.secureHost, 'localhost');
+});
+
+test('custom httpHandler is set', t => {
+  const fakeHandler = { handleHttp1Request() {}, handleHttp2Stream() {} };
+  const listener = new HttpListener({ httpHandler: fakeHandler });
+  t.is(listener.httpHandler, fakeHandler);
+});

package/test/helpers/HttpListener/doubleCreate.js

@@ -0,0 +1,40 @@
+import test from 'ava';
+
+import HttpListener, { SERVER_ALREADY_CREATED } from '../../../helpers/HttpListener.js';
+
+// Test double server creation throws error
+test('createHttpServer throws if called twice with custom options', (t) => {
+  const listener = new HttpListener();
+  listener.createHttpServer();
+  t.notThrows(() => listener.createHttpServer());
+  t.notThrows(() => listener.createHttpServer({}));
+  const err = t.throws(() => listener.createHttpServer({ maxHeaderSize: 8192 }));
+  t.truthy(err);
+  t.is(err.message, SERVER_ALREADY_CREATED);
+});
+
+// Use environment variables for PEM string values
+const key = process.env.TEST_SSL_KEY;
+const cert = process.env.TEST_SSL_CERT;
+const haveCerts = key && cert;
+const testFn = (haveCerts ? test : test.skip);
+
+testFn('createHttpsServer throws if called twice with custom options', (t) => {
+  const listener = new HttpListener({ useHttps: true, tlsOptions: { key, cert } });
+  listener.createHttpsServer();
+  t.notThrows(() => listener.createHttpsServer());
+  t.notThrows(() => listener.createHttpsServer({}));
+  const err = t.throws(() => listener.createHttpsServer({ maxHeaderSize: 8192 }));
+  t.truthy(err);
+  t.is(err.message, SERVER_ALREADY_CREATED);
+});
+
+testFn('createHttp2Server throws if called twice with custom options', (t) => {
+  const listener = new HttpListener({ useHttp2: true, tlsOptions: { key, cert } });
+  listener.createHttp2Server();
+  t.notThrows(() => listener.createHttp2Server());
+  t.notThrows(() => listener.createHttp2Server({}));
+  const err = t.throws(() => listener.createHttp2Server({ settings: { maxConcurrentStreams: 100 } }));
+  t.truthy(err);
+  t.is(err.message, SERVER_ALREADY_CREATED);
+});