@react-router/node 7.15.0 → 7.16.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # `@react-router/node`
 
+## v7.16.0
+
+### Patch Changes
+
+- Honor Node writable backpressure in `writeReadableStreamToWritable` and `writeAsyncIterableToWritable` ([#15071](https://github.com/remix-run/react-router/pull/15071))
+
+  - Await `'drain'` when `writable.write()` returns `false` instead of letting chunks accumulate in the writable's internal buffer.
+  - Reject (rather than hang) if the writable errors or closes mid-stream.
+- Updated dependencies:
+  - [`react-router@7.16.0`](https://github.com/remix-run/react-router/releases/tag/react-router@7.16.0)
+
+## v7.15.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - [`react-router@7.15.1`](https://github.com/remix-run/react-router/releases/tag/react-router@7.15.1)
+
 ## v7.15.0
 
 ### Patch Changes

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/node v7.15.0
+ * @react-router/node v7.16.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -144,32 +144,131 @@ var import_node_stream = require("stream");
 async function writeReadableStreamToWritable(stream, writable) {
   let reader = stream.getReader();
   let flushable = writable;
+  let writableError = monitorWritableError(writable);
   try {
     while (true) {
-      let { done, value } = await reader.read();
+      writableError.throwIfClosed();
+      let { done, value } = await writableError.race(reader.read());
       if (done) {
         writable.end();
         break;
       }
-      writable.write(value);
+      writableError.throwIfClosed();
+      let canContinueWriting = writable.write(value);
       if (typeof flushable.flush === "function") {
         flushable.flush();
       }
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
     }
   } catch (error) {
+    try {
+      reader.cancel(error).catch(() => {
+      });
+    } catch {
+    }
     writable.destroy(error);
     throw error;
+  } finally {
+    writableError.cleanup();
+    try {
+      reader.releaseLock();
+    } catch {
+    }
   }
 }
+function monitorWritableError(writable) {
+  let settled = false;
+  let writableError;
+  let rejectWritableError;
+  let writableErrorPromise = new Promise((_, reject2) => {
+    rejectWritableError = reject2;
+  });
+  writableErrorPromise.catch(() => {
+  });
+  function cleanup() {
+    writable.off("error", onError);
+    writable.off("close", onClose);
+  }
+  function reject(error) {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    writableError = error;
+    cleanup();
+    rejectWritableError(error);
+  }
+  function onError(error) {
+    reject(error);
+  }
+  function onClose() {
+    reject(new Error("Writable closed before stream finished"));
+  }
+  writable.once("error", onError);
+  writable.once("close", onClose);
+  return {
+    cleanup,
+    race(promise) {
+      return Promise.race([promise, writableErrorPromise]);
+    },
+    throwIfClosed() {
+      if (writableError) {
+        throw writableError;
+      }
+      if (writable.destroyed || writable.writableEnded) {
+        throw new Error("Cannot write to a destroyed or ended writable stream");
+      }
+    }
+  };
+}
+function waitForDrain(writable, writableError) {
+  let cleanup = () => {
+  };
+  let drainPromise = new Promise((resolve) => {
+    function onDrain() {
+      cleanup();
+      resolve();
+    }
+    cleanup = function cleanup2() {
+      writable.off("drain", onDrain);
+    };
+    writable.once("drain", onDrain);
+  });
+  return writableError.race(drainPromise).finally(cleanup);
+}
 async function writeAsyncIterableToWritable(iterable, writable) {
+  let writableError = monitorWritableError(writable);
+  let iterator = iterable[Symbol.asyncIterator]();
+  let completed = false;
   try {
-    for await (let chunk of iterable) {
-      writable.write(chunk);
+    while (true) {
+      writableError.throwIfClosed();
+      let { done, value: chunk } = await writableError.race(iterator.next());
+      if (done) {
+        completed = true;
+        break;
+      }
+      writableError.throwIfClosed();
+      let canContinueWriting = writable.write(chunk);
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
     }
     writable.end();
   } catch (error) {
+    if (!completed) {
+      try {
+        Promise.resolve(iterator.return?.()).catch(() => {
+        });
+      } catch {
+      }
+    }
     writable.destroy(error);
     throw error;
+  } finally {
+    writableError.cleanup();
   }
 }
 async function readableStreamToString(stream, encoding) {
@@ -235,7 +334,7 @@ var StreamPump = class {
         if (available <= 0) {
           this.pause();
         }
-      } catch (error) {
+      } catch (e) {
         this.controller.error(
           new Error(
             "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"

package/dist/index.mjs

@@ -1,5 +1,5 @@
 /**
- * @react-router/node v7.15.0
+ * @react-router/node v7.16.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -104,32 +104,131 @@ import { Stream } from "stream";
 async function writeReadableStreamToWritable(stream, writable) {
   let reader = stream.getReader();
   let flushable = writable;
+  let writableError = monitorWritableError(writable);
   try {
     while (true) {
-      let { done, value } = await reader.read();
+      writableError.throwIfClosed();
+      let { done, value } = await writableError.race(reader.read());
       if (done) {
         writable.end();
         break;
       }
-      writable.write(value);
+      writableError.throwIfClosed();
+      let canContinueWriting = writable.write(value);
       if (typeof flushable.flush === "function") {
         flushable.flush();
       }
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
     }
   } catch (error) {
+    try {
+      reader.cancel(error).catch(() => {
+      });
+    } catch {
+    }
     writable.destroy(error);
     throw error;
+  } finally {
+    writableError.cleanup();
+    try {
+      reader.releaseLock();
+    } catch {
+    }
   }
 }
+function monitorWritableError(writable) {
+  let settled = false;
+  let writableError;
+  let rejectWritableError;
+  let writableErrorPromise = new Promise((_, reject2) => {
+    rejectWritableError = reject2;
+  });
+  writableErrorPromise.catch(() => {
+  });
+  function cleanup() {
+    writable.off("error", onError);
+    writable.off("close", onClose);
+  }
+  function reject(error) {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    writableError = error;
+    cleanup();
+    rejectWritableError(error);
+  }
+  function onError(error) {
+    reject(error);
+  }
+  function onClose() {
+    reject(new Error("Writable closed before stream finished"));
+  }
+  writable.once("error", onError);
+  writable.once("close", onClose);
+  return {
+    cleanup,
+    race(promise) {
+      return Promise.race([promise, writableErrorPromise]);
+    },
+    throwIfClosed() {
+      if (writableError) {
+        throw writableError;
+      }
+      if (writable.destroyed || writable.writableEnded) {
+        throw new Error("Cannot write to a destroyed or ended writable stream");
+      }
+    }
+  };
+}
+function waitForDrain(writable, writableError) {
+  let cleanup = () => {
+  };
+  let drainPromise = new Promise((resolve) => {
+    function onDrain() {
+      cleanup();
+      resolve();
+    }
+    cleanup = function cleanup2() {
+      writable.off("drain", onDrain);
+    };
+    writable.once("drain", onDrain);
+  });
+  return writableError.race(drainPromise).finally(cleanup);
+}
 async function writeAsyncIterableToWritable(iterable, writable) {
+  let writableError = monitorWritableError(writable);
+  let iterator = iterable[Symbol.asyncIterator]();
+  let completed = false;
   try {
-    for await (let chunk of iterable) {
-      writable.write(chunk);
+    while (true) {
+      writableError.throwIfClosed();
+      let { done, value: chunk } = await writableError.race(iterator.next());
+      if (done) {
+        completed = true;
+        break;
+      }
+      writableError.throwIfClosed();
+      let canContinueWriting = writable.write(chunk);
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
     }
     writable.end();
   } catch (error) {
+    if (!completed) {
+      try {
+        Promise.resolve(iterator.return?.()).catch(() => {
+        });
+      } catch {
+      }
+    }
     writable.destroy(error);
     throw error;
+  } finally {
+    writableError.cleanup();
   }
 }
 async function readableStreamToString(stream, encoding) {
@@ -195,7 +294,7 @@ var StreamPump = class {
         if (available <= 0) {
           this.pause();
         }
-      } catch (error) {
+      } catch (e) {
         this.controller.error(
           new Error(
             "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-router/node",
-  "version": "7.15.0",
+  "version": "7.16.0",
   "description": "Node.js platform abstractions for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
@@ -53,11 +53,11 @@
     "tsup": "^8.3.0",
     "typescript": "^5.4.5",
     "wireit": "0.14.9",
-    "react-router": "7.15.0"
+    "react-router": "7.16.0"
   },
   "peerDependencies": {
     "typescript": "^5.1.0 || ^6.0.0",
-    "react-router": "7.15.0"
+    "react-router": "7.16.0"
   },
   "peerDependenciesMeta": {
     "typescript": {