webhoster 0.3.0 → 0.3.2

package/lib/HttpResponse.js

@@ -5,7 +5,7 @@
 
 /** @typedef {import('stream').Writable} Writable */
 
-import { PassThrough, Readable, pipeline } from 'node:stream';
+import { PassThrough, pipeline } from 'node:stream';
 
 import { isWritable } from '../utils/stream.js';
 
@@ -124,7 +124,7 @@ export default class HttpResponse {
   async sendRaw(body) {
     this.body = body;
     await new Promise((resolve, reject) => {
-      this.stream.end(body, (err) => (err ? reject(err) : resolve()));
+      this.stream.end(body, (error) => (error ? reject(error) : resolve()));
     });
     return 0;
   }
@@ -162,8 +162,8 @@ export default class HttpResponse {
       // Called directly by user and needs finalizer calls
 
       this.isStreaming = true;
-      for (let i = 0; i < this.finalizers.length; i++) {
-        const process = this.finalizers[i];
+      for (let index = 0; index < this.finalizers.length; index++) {
+        const process = this.finalizers[index];
         const result = process(this);
         if (result === false) {
           break;
@@ -185,11 +185,11 @@ export default class HttpResponse {
 
     this.#pipeline = array[0];
     // @ts-ignore Bad typings
-    pipeline(array, (err) => {
+    pipeline(array, (error) => {
       this.#pipelineComplete = true;
       let nextCallback;
       while ((nextCallback = this.#pipelineCallbacks.shift()) != null) {
-        nextCallback(err);
+        nextCallback(error);
       }
     });
     return this.#pipeline;
@@ -209,7 +209,8 @@ export default class HttpResponse {
     if (body !== undefined) {
       this.body = body;
     }
-    if (this.body instanceof Readable) {
+    if (typeof this.body === 'object' && this.body !== null
+      && (Symbol.asyncIterator in this.body)) {
       this.isStreaming = true;
       this.pipes.push(this.body);
     }
@@ -234,8 +235,8 @@ export default class HttpResponse {
     if (!isWritable(this.stream)) return 0;
     if (this.isStreaming) {
       await new Promise((resolve, reject) => {
-        this.getPipeline((err) => {
-          if (err) reject(err);
+        this.getPipeline((error) => {
+          if (error) reject(error);
           resolve();
         });
       });
@@ -268,7 +269,8 @@ export default class HttpResponse {
       this.body = body;
     }
 
-    if (this.body instanceof Readable) {
+    if (typeof this.body === 'object' && this.body !== null
+      && (Symbol.asyncIterator in this.body)) {
       this.isStreaming = true;
       this.pipes.push(this.body);
     }
@@ -279,9 +281,9 @@ export default class HttpResponse {
     let needsAsync = false;
     /** @type {void|Promise<boolean|void>} */
     let pendingPromise;
-    let i;
-    for (i = 0; i < this.finalizers.length; i++) {
-      const process = this.finalizers[i];
+    let index;
+    for (index = 0; index < this.finalizers.length; index++) {
+      const process = this.finalizers[index];
       if (needsAsync) {
         pendingProcessors.push(process);
         continue;
@@ -301,8 +303,8 @@ export default class HttpResponse {
     if (pendingPromise) {
       pendingPromise.then(async (initialResult) => {
         if (initialResult !== false) {
-          for (i = 0; i < pendingProcessors.length; i++) {
-            const process = pendingProcessors[i];
+          for (index = 0; index < pendingProcessors.length; index++) {
+            const process = pendingProcessors[index];
             const result = process(this);
             if (result === true || result == null) {
               continue;

package/package.json

@@ -50,5 +50,5 @@
     "posttestall": "c8 report"
   },
   "type": "module",
-  "version": "0.3.0"
+  "version": "0.3.2"
 }

package/scripts/check-teapot.mjs

@@ -0,0 +1,40 @@
+import http from 'node:http';
+import * as starter from '../templates/starter.js';
+
+async function run() {
+  const throwingMiddleware = [() => { throw new Error('brew failed'); }];
+  const teapotHandler = {
+    onError(transaction) {
+      transaction.response.status = 418;
+      return "I'm a teapot";
+    },
+  };
+
+  const listener = await starter.start({ middleware: throwingMiddleware, errorHandlers: [teapotHandler], host: '127.0.0.1', port: 0 });
+  try {
+    const addr = listener.httpServer.address();
+    const port = typeof addr === 'object' ? addr.port : addr;
+    const result = await new Promise((resolve, reject) => {
+      const req = http.get({ port, path: '/' }, (res) => {
+        let data = '';
+        res.setEncoding('utf8');
+        res.on('data', (c) => { data += c; });
+        res.on('end', () => resolve({ status: res.statusCode, body: data }));
+      });
+      req.on('error', reject);
+    });
+
+    // Print a concise confirmation
+    // (CI will show this output in the terminal)
+    // eslint-disable-next-line no-console
+    console.log('TEAPOT_CHECK_RESULT', JSON.stringify(result));
+  } finally {
+    await listener.stopHttpServer();
+  }
+}
+
+run().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error('check-teapot failed', err);
+  process.exit(1);
+});

package/templates/starter.js

@@ -32,7 +32,9 @@ export async function start(options) {
     // Push by reference to allow post modification
     HttpHandler.defaultInstance.middleware.push(options.middleware);
   }
-  if (!options.errorHandlers) {
+  if (options.errorHandlers) {
+    HttpHandler.defaultInstance.errorHandlers.push(...options.errorHandlers);
+  } else {
     HttpHandler.defaultInstance.errorHandlers.push(
       {
         onError() {

package/test/lib/HttpResponse/async-iterable-middleware.js

@@ -0,0 +1,37 @@
+import test from 'ava';
+import { PassThrough } from 'node:stream';
+
+import HttpHandler from '../../../lib/HttpHandler.js';
+import HttpResponse from '../../../lib/HttpResponse.js';
+import HttpTransaction from '../../../lib/HttpTransaction.js';
+
+test('middleware can return async iterable body', async (t) => {
+  const stream = new PassThrough();
+  const reader = new PassThrough();
+  stream.pipe(reader);
+
+  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
+  const transaction = new HttpTransaction({ request: {}, response, socket: {}, httpVersion: '1.1' });
+
+  const handler = new HttpHandler();
+
+  // Middleware returns an async generator (async iterable)
+  const mw = async () => {
+    async function* gen() {
+      yield Buffer.from('m1-');
+      await new Promise((r) => setTimeout(r, 0));
+      yield Buffer.from('m2');
+    }
+    return gen();
+  };
+
+  const result = await handler.processMiddleware(transaction, mw);
+  t.truthy(result !== undefined);
+
+  let out = '';
+  for await (const chunk of reader) {
+    out += chunk.toString();
+  }
+
+  t.is(out, 'm1-m2');
+});

package/test/lib/HttpResponse/async-iterable.js

@@ -0,0 +1,31 @@
+import test from 'ava';
+import { PassThrough } from 'node:stream';
+
+import HttpHandler from '../../../lib/HttpHandler.js';
+import HttpResponse from '../../../lib/HttpResponse.js';
+
+test('HttpResponse.send() accepts async iterable body', async (t) => {
+  const stream = new PassThrough();
+  const reader = new PassThrough();
+  stream.pipe(reader);
+
+  const response = new HttpResponse({ stream, onSendHeaders: () => {} });
+
+  async function* gen() {
+    yield Buffer.from('chunk1-');
+    // allow microtask scheduling
+    await new Promise((r) => setTimeout(r, 0));
+    yield Buffer.from('chunk2');
+  }
+
+  response.body = gen();
+
+  const result = await response.send();
+  t.is(result, HttpHandler.END);
+
+  let out = '';
+  for await (const chunk of reader) {
+    out += chunk.toString();
+  }
+  t.is(out, 'chunk1-chunk2');
+});

package/test/templates/error-teapot.js

@@ -0,0 +1,47 @@
+import test from 'ava';
+import http from 'node:http';
+import HttpListener from '../../helpers/HttpListener.js';
+import HttpHandler from '../../lib/HttpHandler.js';
+import * as starter from '../../templates/starter.js';
+
+test.serial('custom error handler returns 418 I\'m a teapot', async (t) => {
+  const handler = HttpHandler.defaultInstance;
+  const listener = HttpListener.defaultInstance;
+
+  const mwLen = handler.middleware.length;
+  const ehLen = handler.errorHandlers.length;
+
+  const throwingMiddleware = [() => { throw new Error('brew failed'); }];
+  const teapotHandler = {
+    onError(transaction) {
+      // set custom status and body
+      transaction.response.status = 418;
+      return "I'm a teapot";
+    },
+  };
+
+  await starter.start({ middleware: throwingMiddleware, errorHandlers: [teapotHandler], host: '127.0.0.1', port: 0 });
+
+  t.truthy(listener.httpServer, 'server started');
+  const addr = listener.httpServer.address();
+  t.truthy(addr && addr.port, 'server bound');
+
+  const result = await new Promise((resolve, reject) => {
+    const req = http.get({ port: addr.port, path: '/' }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => resolve({ status: res.statusCode, body: data }));
+    });
+    req.on('error', reject);
+  });
+
+  t.is(result.status, 418);
+  t.true(result.body.includes("teapot"));
+
+  await listener.stopHttpServer();
+
+  // restore global handler state
+  handler.middleware.splice(mwLen);
+  handler.errorHandlers.splice(ehLen);
+});

package/test/templates/starter.js

@@ -82,9 +82,9 @@ test.serial('starter.start respects provided errorHandlers and pushes middleware
   const lastMw = handler.middleware.at(-1);
   t.is(lastMw, customMiddleware);
 
-  // The implementation does not automatically append provided `errorHandlers`;
-  // it only avoids adding the default when `options.errorHandlers` is supplied.
-  t.is(handler.errorHandlers.length, ehLength);
+  // Provided errorHandlers are appended to the handler.
+  t.is(handler.errorHandlers.length, ehLength + customHandlers.length);
+  t.is(handler.errorHandlers.at(-1), customHandlers.at(-1));
 
   await listener.stopHttpServer();