@jsenv/server 15.5.3 → 16.0.1

package/src/interfacing_with_node/observable.js

@@ -1,3 +1,5 @@
+// https://wicg.github.io/observable/#core-infrastructure
+
 if ("observable" in Symbol === false) {
   Symbol.observable = Symbol.for("observable");
 }
@@ -9,40 +11,73 @@ export const createObservable = (producer) => {
 
   const observable = {
     [Symbol.observable]: () => observable,
-    subscribe: ({
-      next = () => {},
-      error = (value) => {
-        throw value;
+    subscribe: (
+      {
+        next = () => {},
+        error = (value) => {
+          throw value;
+        },
+        complete = () => {},
       },
-      complete = () => {},
-    }) => {
+      { signal = new AbortController().signal } = {},
+    ) => {
       let cleanup = () => {};
       const subscription = {
-        closed: false,
+        active: true,
+        signal,
         unsubscribe: () => {
           subscription.closed = true;
           cleanup();
         },
       };
 
+      const teardownCallbackList = [];
+      const close = () => {
+        subscription.active = false;
+        let i = teardownCallbackList.length;
+        while (i--) {
+          teardownCallbackList[i]();
+        }
+        teardownCallbackList.length = 0;
+      };
+
+      signal.addEventListener("abort", () => {
+        close();
+      });
+
       const producerReturnValue = producer({
         next: (value) => {
-          if (subscription.closed) return;
+          if (!subscription.active) {
+            return;
+          }
           next(value);
         },
         error: (value) => {
-          if (subscription.closed) return;
+          if (!subscription.active) {
+            return;
+          }
           error(value);
+          close();
         },
         complete: () => {
-          if (subscription.closed) return;
+          if (!subscription.active) {
+            return;
+          }
           complete();
+          close();
+        },
+        addTeardown: (teardownCallback) => {
+          if (!subscription.active) {
+            teardownCallback();
+            return;
+          }
+          teardownCallbackList.push(teardownCallback);
         },
       });
       if (typeof producerReturnValue === "function") {
         cleanup = producerReturnValue;
       }
-      return subscription;
+      return undefined;
     },
   };
 
@@ -61,47 +96,27 @@ export const isObservable = (value) => {
   return false;
 };
 
-export const observableFromValue = (value) => {
-  if (isObservable(value)) {
-    return value;
-  }
-
-  return createObservable(({ next, complete }) => {
-    next(value);
-    const timer = setTimeout(() => {
-      complete();
-    });
-    return () => {
-      clearTimeout(timer);
-    };
-  });
-};
-
 export const createCompositeProducer = ({ cleanup = () => {} } = {}) => {
-  const observables = new Set();
-  const observers = new Set();
-
+  const observableSet = new Set();
+  const observerSet = new Set();
   const addObservable = (observable) => {
-    if (observables.has(observable)) {
+    if (observableSet.has(observable)) {
       return false;
     }
-
-    observables.add(observable);
-    observers.forEach((observer) => {
+    observableSet.add(observable);
+    for (const observer of observerSet) {
       observer.observe(observable);
-    });
+    }
     return true;
   };
-
   const removeObservable = (observable) => {
-    if (!observables.has(observable)) {
+    if (!observableSet.has(observable)) {
       return false;
     }
-
-    observables.delete(observable);
-    observers.forEach((observer) => {
+    observableSet.delete(observable);
+    for (const observer of observerSet) {
       observer.unobserve(observable);
-    });
+    }
     return true;
   };
 
@@ -109,63 +124,64 @@ export const createCompositeProducer = ({ cleanup = () => {} } = {}) => {
     next = () => {},
     complete = () => {},
     error = () => {},
+    addTeardown = () => {},
   }) => {
     let completeCount = 0;
-
     const checkComplete = () => {
-      if (completeCount === observables.size) {
+      if (completeCount === observableSet.size) {
         complete();
       }
     };
+    addTeardown(() => {
+      for (const [, abort] of abortMap) {
+        abort();
+      }
+      abortMap.clear();
+      cleanup();
+    });
 
-    const subscriptions = new Map();
+    const abortMap = new Map();
     const observe = (observable) => {
-      const subscription = observable.subscribe({
-        next: (value) => {
-          next(value);
-        },
-        error: (value) => {
-          error(value);
-        },
-        complete: () => {
-          subscriptions.delete(observable);
-          completeCount++;
-          checkComplete();
+      const abortController = new AbortController();
+      observable.subscribe(
+        {
+          next: (value) => {
+            next(value);
+          },
+          error: (value) => {
+            error(value);
+          },
+          complete: () => {
+            abortMap.delete(observable);
+            completeCount++;
+            checkComplete();
+          },
         },
+        { signal: abortController.signal },
+      );
+      abortMap.set(observable, () => {
+        abortController.abort();
       });
-      subscriptions.set(observable, subscription);
     };
     const unobserve = (observable) => {
-      const subscription = subscriptions.get(observable);
-      if (!subscription) {
+      const abort = abortMap.get(observable);
+      if (!abort) {
         return;
       }
-
-      subscription.unsubscribe();
-      subscriptions.delete(observable);
+      abortMap.delete(observable);
+      abort();
       checkComplete();
     };
     const observer = {
       observe,
       unobserve,
     };
-    observers.add(observer);
-    observables.forEach((observable) => {
+    observerSet.add(observer);
+    for (const observable of observableSet) {
       observe(observable);
-    });
-
-    return () => {
-      observers.delete(observer);
-      subscriptions.forEach((subscription) => {
-        subscription.unsubscribe();
-      });
-      subscriptions.clear();
-      cleanup();
-    };
+    }
   };
-
   producer.addObservable = addObservable;
   producer.removeObservable = removeObservable;
-
   return producer;
 };

package/src/interfacing_with_node/observable_from.js

@@ -0,0 +1,34 @@
+import { getObservableValueType } from "./get_observable_value_type.js";
+import { createObservable } from "./observable.js";
+import { observableFromFileHandle } from "./observable_from_file_handle.js";
+import { observableFromNodeStream } from "./observable_from_node_stream.js";
+import { observableFromNodeWebReadableStream } from "./observable_from_node_web_readable_stream.js";
+import { observableFromPromise } from "./observable_from_promise.js";
+
+export const observableFromValue = (value) => {
+  const observableValueType = getObservableValueType(value);
+  if (observableValueType === "observable") {
+    return value;
+  }
+  if (observableValueType === "promise") {
+    return observableFromPromise(value);
+  }
+  if (observableValueType === "file_handle") {
+    return observableFromFileHandle(value);
+  }
+  if (observableValueType === "node_stream") {
+    return observableFromNodeStream(value);
+  }
+  if (observableValueType === "node_web_stream") {
+    return observableFromNodeWebReadableStream(value);
+  }
+  return createObservable(({ next, complete, addTeardown }) => {
+    next(value);
+    const timer = setTimeout(() => {
+      complete();
+    });
+    addTeardown(() => {
+      clearTimeout(timer);
+    });
+  });
+};

package/src/interfacing_with_node/observable_from_file_handle.js

@@ -0,0 +1,30 @@
+import { createReadStream } from "node:fs";
+import { observableFromNodeStream } from "./observable_from_node_stream.js";
+
+export const isFileHandle = (value) => {
+  return value && value.constructor && value.constructor.name === "FileHandle";
+};
+
+export const observableFromFileHandle = (fileHandle) => {
+  return observableFromNodeStream(fileHandleToReadableStream(fileHandle));
+};
+
+export const fileHandleToReadableStream = (fileHandle) => {
+  const fileReadableStream =
+    typeof fileHandle.createReadStream === "function"
+      ? fileHandle.createReadStream()
+      : createReadStream(
+          "/toto", // is it ok to pass a fake path like this?
+          {
+            fd: fileHandle.fd,
+            emitClose: true,
+            // autoClose: true
+          },
+        );
+  // I suppose it's required only when doing fs.createReadStream()
+  // and not fileHandle.createReadStream()
+  // fileReadableStream.on("end", () => {
+  //   fileHandle.close()
+  // })
+  return fileReadableStream;
+};

package/src/interfacing_with_node/observable_from_node_stream.js

@@ -4,58 +4,56 @@ import { createObservable } from "./observable.js";
 
 export const observableFromNodeStream = (
   nodeStream,
-  {
-    readableStreamLifetime = 120_000, // 2s
-  } = {},
+  { readableLifetime } = {},
 ) => {
-  const observable = createObservable(({ next, error, complete }) => {
-    if (nodeStream.isPaused()) {
-      nodeStream.resume();
-    } else if (nodeStream.complete) {
-      complete();
-      return null;
-    }
-    const cleanup = () => {
-      nodeStream.removeListener("data", next);
-      nodeStream.removeListener("error", error);
-      nodeStream.removeListener("end", complete);
-      nodeStream.removeListener("close", cleanup);
-      nodeStream.destroy();
-    };
-    // should we do nodeStream.resume() in case the stream was paused ?
-    nodeStream.once("error", error);
-    nodeStream.on("data", (data) => {
-      next(data);
-    });
-    nodeStream.once("close", () => {
-      cleanup();
-    });
-    nodeStream.once("end", () => {
-      complete();
-    });
-    return cleanup;
-  });
+  const observable = createObservable(
+    ({ next, error, complete, addTeardown }) => {
+      const errorEventCallback = (e) => {
+        error(e);
+      };
+      const dataEventCallback = (data) => {
+        next(data);
+      };
+      const closeEventCallback = () => {
+        complete();
+      };
+      const endEventCallback = () => {
+        complete();
+      };
+      nodeStream.once("error", errorEventCallback);
+      nodeStream.on("data", dataEventCallback);
+      nodeStream.once("end", endEventCallback);
+      nodeStream.once("close", closeEventCallback); // not sure it's required
+      addTeardown(() => {
+        nodeStream.removeListener("error", errorEventCallback);
+        nodeStream.removeListener("data", dataEventCallback);
+        nodeStream.removeListener("end", endEventCallback);
+        nodeStream.removeListener("close", closeEventCallback); // not sure it's required
+      });
+      if (nodeStream.isPaused()) {
+        nodeStream.resume();
+      } else if (nodeStream.complete) {
+        complete();
+      }
+    },
+  );
 
-  if (nodeStream instanceof Readable) {
-    // safe measure, ensure the readable stream gets
-    // used in the next ${readableStreamLifetimeInSeconds} otherwise destroys it
+  if (readableLifetime && nodeStream instanceof Readable) {
     const timeout = setTimeout(() => {
-      process.emitWarning(
-        `Readable stream not used after ${
-          readableStreamLifetime / 1000
-        } seconds. It will be destroyed to release resources`,
-        {
-          CODE: "READABLE_STREAM_TIMEOUT",
-          // url is for http client request
-          detail: `path: ${nodeStream.path}, fd: ${nodeStream.fd}, url: ${nodeStream.url}`,
-        },
-      );
-      nodeStream.destroy();
-    }, readableStreamLifetime);
-    observable.timeout = timeout;
+      // disabled for now
+      // process.emitWarning(
+      //   `Readable stream not used after ${readableLifetime / 1000} seconds.`,
+      //   {
+      //     CODE: "READABLE_STREAM_TIMEOUT",
+      //     // url is for http client request
+      //     detail: `path: ${nodeStream.path}, fd: ${nodeStream.fd}, url: ${nodeStream.url}`,
+      //   },
+      // );
+    }, readableLifetime).unref();
     onceReadableStreamUsedOrClosed(nodeStream, () => {
       clearTimeout(timeout);
     });
+    observable.timeout = timeout;
   }
 
   return observable;

package/src/interfacing_with_node/observable_from_node_web_readable_stream.js

@@ -0,0 +1,32 @@
+// https://nodejs.org/api/webstreams.html#readablestreamgetreaderoptions
+// https://nodejs.org/api/webstreams.html
+// we can read as text using TextDecoder, see https://developer.mozilla.org/fr/docs/Web/API/Fetch_API/Using_Fetch#traiter_un_fichier_texte_ligne_%C3%A0_ligne
+import { createObservable } from "./observable.js";
+
+export const observableFromNodeWebReadableStream = (nodeWebReadableStream) => {
+  const observable = createObservable(
+    ({ next, error, complete, addTeardown }) => {
+      const reader = nodeWebReadableStream.getReader();
+
+      const readNext = async () => {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            complete();
+            return;
+          }
+          next(value);
+          readNext();
+        } catch (e) {
+          error(e);
+        }
+      };
+      readNext();
+      addTeardown(() => {
+        reader.cancel();
+      });
+    },
+  );
+
+  return observable;
+};

package/src/interfacing_with_node/observable_from_promise.js

@@ -0,0 +1,13 @@
+import { createObservable } from "./observable.js";
+
+export const observableFromPromise = (promise) => {
+  return createObservable(async ({ next, error, complete }) => {
+    try {
+      const value = await promise;
+      next(value);
+      complete();
+    } catch (e) {
+      error(e);
+    }
+  });
+};

package/src/interfacing_with_node/write_node_response.js

@@ -1,19 +1,46 @@
 import { raceCallbacks } from "@jsenv/abort";
 import http from "node:http";
 import { Http2ServerResponse } from "node:http2";
-
-import { normalizeBodyMethods } from "./body.js";
+import { Socket } from "node:net";
+import { getObservableValueType } from "./get_observable_value_type.js";
+import { observableFromValue } from "./observable_from.js";
 
 export const writeNodeResponse = async (
   responseStream,
   { status, statusText, headers, body, bodyEncoding },
   { signal, ignoreBody, onAbort, onError, onHeadersSent, onEnd } = {},
 ) => {
-  body = await body;
-  const bodyMethods = normalizeBodyMethods(body);
+  const isNetSocket = responseStream instanceof Socket;
+  if (
+    body &&
+    body.isObservableBody &&
+    headers["connection"] === undefined &&
+    headers["content-length"] === undefined
+  ) {
+    headers["transfer-encoding"] = "chunked";
+  }
+  // if (body && headers["content-length"] === undefined) {
+  //   headers["transfer-encoding"] = "chunked";
+  // }
+
+  const bodyObservableType = getObservableValueType(body);
+  const destroyBody = () => {
+    if (bodyObservableType === "file_handle") {
+      body.close();
+      return;
+    }
+    if (bodyObservableType === "node_stream") {
+      body.destroy();
+      return;
+    }
+    if (bodyObservableType === "node_web_stream") {
+      body.cancel();
+      return;
+    }
+  };
 
   if (signal.aborted) {
-    bodyMethods.destroy();
+    destroyBody();
     responseStream.destroy();
     onAbort();
     return;
@@ -34,43 +61,50 @@ export const writeNodeResponse = async (
 
   if (ignoreBody) {
     onEnd();
-    bodyMethods.destroy();
+    destroyBody();
     responseStream.end();
     return;
   }
 
-  if (bodyEncoding) {
+  if (bodyEncoding && !isNetSocket) {
     responseStream.setEncoding(bodyEncoding);
   }
 
   await new Promise((resolve) => {
-    const observable = bodyMethods.asObservable();
-    const subscription = observable.subscribe({
-      next: (data) => {
-        try {
-          responseStream.write(data);
-        } catch (e) {
-          // Something inside Node.js sometimes puts stream
-          // in a state where .write() throw despites nodeResponse.destroyed
-          // being undefined and "close" event not being emitted.
-          // I have tested if we are the one calling destroy
-          // (I have commented every .destroy() call)
-          // but issue still occurs
-          // For the record it's "hard" to reproduce but can be by running
-          // a lot of tests against a browser in the context of @jsenv/core testing
-          if (e.code === "ERR_HTTP2_INVALID_STREAM") {
-            return;
+    const observable = observableFromValue(body);
+    const abortController = new AbortController();
+    signal.addEventListener("abort", () => {
+      abortController.abort();
+    });
+    observable.subscribe(
+      {
+        next: (data) => {
+          try {
+            responseStream.write(data);
+          } catch (e) {
+            // Something inside Node.js sometimes puts stream
+            // in a state where .write() throw despites nodeResponse.destroyed
+            // being undefined and "close" event not being emitted.
+            // I have tested if we are the one calling destroy
+            // (I have commented every .destroy() call)
+            // but issue still occurs
+            // For the record it's "hard" to reproduce but can be by running
+            // a lot of tests against a browser in the context of @jsenv/core testing
+            if (e.code === "ERR_HTTP2_INVALID_STREAM") {
+              return;
+            }
+            responseStream.emit("error", e);
           }
-          responseStream.emit("error", e);
-        }
-      },
-      error: (value) => {
-        responseStream.emit("error", value);
-      },
-      complete: () => {
-        responseStream.end();
+        },
+        error: (value) => {
+          responseStream.emit("error", value);
+        },
+        complete: () => {
+          responseStream.end();
+        },
       },
-    });
+      { signal: abortController.signal },
+    );
 
     raceCallbacks(
       {
@@ -102,13 +136,13 @@ export const writeNodeResponse = async (
       (winner) => {
         const raceEffects = {
           abort: () => {
-            subscription.unsubscribe();
+            abortController.abort();
             responseStream.destroy();
             onAbort();
             resolve();
           },
           error: (error) => {
-            subscription.unsubscribe();
+            abortController.abort();
             responseStream.destroy();
             onError(error);
             resolve();
@@ -119,7 +153,7 @@ export const writeNodeResponse = async (
             // it may happen in case of server sent event
             // where body is kept open to write to client
             // and the browser is reloaded or closed for instance
-            subscription.unsubscribe();
+            abortController.abort();
             responseStream.destroy();
             onAbort();
             resolve();
@@ -139,6 +173,7 @@ const writeHead = (
   responseStream,
   { status, statusText, headers, onHeadersSent },
 ) => {
+  const responseIsNetSocket = responseStream instanceof Socket;
   const responseIsHttp2ServerResponse =
     responseStream instanceof Http2ServerResponse;
   const responseIsServerHttp2Stream =
@@ -172,6 +207,16 @@ const writeHead = (
     onHeadersSent({ nodeHeaders, status, statusText });
     return;
   }
+  if (responseIsNetSocket) {
+    const headersString = Object.keys(nodeHeaders)
+      .map((h) => `${h}: ${nodeHeaders[h]}`)
+      .join("\r\n");
+    responseStream.write(
+      `HTTP/1.1 ${status} ${statusText}\r\n${headersString}\r\n\r\n`,
+    );
+    onHeadersSent({ nodeHeaders, status, statusText });
+    return;
+  }
 
   try {
     responseStream.writeHead(status, statusText, nodeHeaders);

package/src/internal/colorizeResponseStatus.js

@@ -9,6 +9,8 @@ const magenta = "\x1b[35m";
 const cyan = "\x1b[36m";
 // const white = "\x1b[37m"
 
+export const websocketSuffixColorized = `{ upgrade: ${magenta}websocket${close} }`;
+
 export const colorizeResponseStatus = (status) => {
   const statusType = statusToType(status);
   if (statusType === "information") return `${cyan}${status}${close}`;