webhoster 0.3.1 → 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.1"
+  "version": "0.3.2"
 }

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');
+});