@promistream/from-node-stream 0.1.7 → 0.1.9

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@promistream/from-node-stream",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "main": "src/index.js",
-  "repository": "https://codeberg.org/promistream/from-node-stream.git",
+  "repository": {
+    "type": "git",
+    "url": "https://codeberg.org/promistream/from-node-stream.git"
+  },
   "author": "Sven Slootweg <admin@cryto.net>",
   "license": "WTFPL OR CC0-1.0",
   "dependencies": {
@@ -15,7 +18,7 @@
     "@promistream/propagate-abort": "^0.1.7",
     "@promistream/propagate-peek": "^0.1.2",
     "@promistream/simple-sink": "^0.3.5",
-    "@promistream/simple-source": "^0.1.10",
+    "@promistream/simple-source": "^0.1.11",
     "debug-instanced": "^1.0.0",
     "push-buffer": "^1.5.7",
     "single-concurrent": "^1.0.0",
@@ -23,15 +26,17 @@
   },
   "devDependencies": {
     "@promistream/buffered-map": "^0.1.1",
-    "@promistream/collect": "^0.1.2",
+    "@promistream/collect": "^0.1.4",
     "@promistream/debug": "^0.1.2",
     "@promistream/from-iterable": "^0.1.1",
     "@promistream/map": "^0.1.10",
-    "@promistream/parallelize": "^0.1.8",
+    "@promistream/parallelize": "^0.1.10",
     "@promistream/pipe": "^0.1.8",
     "@promistream/range-numbers": "^0.1.2",
+    "@promistream/spy": "^0.1.0",
+    "@promistream/test-abort": "^0.1.0",
     "bluebird": "^3.7.2",
     "p-defer": "^4.0.1",
     "through2": "^4.0.2"
   }
-}
+}

package/src/index.js

@@ -105,8 +105,12 @@ function convertFromReadable(stream) {
 		onRequest: () => {
 			return read();
 		},
-		onAbort: () => {
-			return abort();
+		onAbort: (reason) => {
+			if (reason === true) {
+				return abort();
+			} else {
+				return abort(reason);
+			}
 		}
 	});
 }
@@ -119,11 +123,26 @@ function isWritableStreamEnded(stream) {
 }
 
 function wireWritable(debug, stream) {
-	let errorEncountered;
+	let errorEncountered, lastAbort;
+	let aborted = false;
+	
+	function abortPromistream(reason) {
+		/* If an abort/end of the underlying Node stream occurred for a reason that's entirely unrelated to our current pipeline - most notably, this happens if the error originates from the *read* side of a non-transform Duplex stream - then we want to make sure that we tear down the Promistream pipeline on this side too. */
+		if (lastAbort != null && !aborted) {
+			aborted = true;
+			lastAbort(reason);
+		}
+	}
 
 	stream.on("error", (error) => {
 		debug("Logging writable interface error:", error);
 		errorEncountered = ensureValidError(error);
+		abortPromistream(error);
+	});
+
+	stream.on("end", () => {
+		debug("Reached end of underlying Writable stream");
+		abortPromistream(true);
 	});
 
 	async function maybeWaitForDrain() {
@@ -145,6 +164,7 @@ function wireWritable(debug, stream) {
 			await maybeWaitForDrain();
 			if (!isStdioStream(stream) && !isWritableStreamEnded(stream)) {
 				debug("Calling .destroy on Writable stream");
+				aborted = true;
 				stream.destroy(error);
 			}
 		},
@@ -152,10 +172,13 @@ function wireWritable(debug, stream) {
 			await maybeWaitForDrain();
 			if (!isStdioStream(stream) && !isWritableStreamEnded(stream)) {
 				debug("Calling .end on Writable stream");
+				aborted = true;
 				stream.end();
 			}
 		},
 		tryWrite: async function (value, abort) {
+			lastAbort = abort;
+			
 			if (isWritableStreamEnded(stream)) {
 				debug("Could not write because underlying stream has ended");
 				if (errorEncountered != null) {
@@ -223,7 +246,7 @@ function convertFromTransform(stream) {
 		// This is essentially a 'background process' of sorts, with manual error handling wiring.
 		try {
 			while (endMarker == null) {
-				await tryWrite(await lastSource.read());
+				await tryWrite(await lastSource.read(), lastSource.abort);
 			}
 		} catch (error) {
 			if (endMarker == null && (isEndOfStream(error) || isAborted(error))) { // FIXME: isExhausted?

package/test.js

@@ -13,7 +13,10 @@ const fromIterable = require("@promistream/from-iterable");
 const fromNodeStream = require(".");
 const collect = require("@promistream/collect");
 const parallelize = require("@promistream/parallelize");
+const testAbort = require("@promistream/test-abort");
 const debug = require("@promistream/debug");
+const { once } = require("node:events");
+const spy = require("@promistream/spy");
 
 test("readable stream", async () => {
 	let testFile = path.join(__dirname, "pnpm-lock.yaml"); // Big-ish file, so we're likely to read in multiple chunks
@@ -24,7 +27,38 @@ test("readable stream", async () => {
 		collect()
 	]).read();
 
-	assert.deepStrictEqual(result, [ expected ]);	
+	assert.deepStrictEqual(result, [ expected ]);
+});
+
+test("readable stream with error abort", { timeout: 500 }, async () => {
+	let testFile = path.join(__dirname, "pnpm-lock.yaml");
+	let nodeStream = fs.createReadStream(testFile);
+
+	let errorFromNodeStreamPromise = once(nodeStream, "error");
+
+	assert.rejects(async () => {
+		let result = await pipe([
+			fromNodeStream.fromReadable(nodeStream),
+			testAbort(0, new Error("sample error")),
+			collect()
+		]).read();
+	}, { message: "sample error" });
+
+	let [ errorFromNodeStream ] = await errorFromNodeStreamPromise;
+	assert.strictEqual(errorFromNodeStream.message, "sample error");
+});
+
+
+test("readable stream with happy abort", { timeout: 500 }, async () => {
+	let testFile = path.join(__dirname, "pnpm-lock.yaml");
+
+	let result = await pipe([
+		fromNodeStream.fromReadable(fs.createReadStream(testFile)),
+		testAbort(0, true),
+		collect()
+	]).read();
+
+	assert.deepStrictEqual(result, []);
 });
 
 test("writable stream", async () => {
@@ -52,6 +86,34 @@ test("writable stream", async () => {
 	assert.strictEqual(endReached, true);
 });
 
+test("writable stream with error abort", async () => {
+	let buffer = Buffer.alloc(400000);
+
+	let writableBuffer = Buffer.alloc(0);
+	let endReached = false;
+	let nodeWritable = new stream.Writable({
+		write(chunk, _encoding, callback) {
+			writableBuffer = Buffer.concat([ writableBuffer, chunk ]);
+			callback();
+		},
+		final(callback) {
+			endReached = true;
+			callback();
+		}
+	});
+
+	await assert.rejects(async () => {
+		await pipe([
+			fromIterable([ buffer, buffer, buffer ]),
+			testAbort(0, new Error("sample error")),
+			fromNodeStream(nodeWritable)
+		]).read();
+	}, { message: "sample error" });
+
+	assert.strictEqual(writableBuffer.length, 0);
+	assert.strictEqual(endReached, false);
+});
+
 test("transform stream", async () => {
 	let result = await pipe([
 		fromIterable([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]),
@@ -73,7 +135,7 @@ test("transform stream", async () => {
 });
 
 test("transform stream with abort", async () => {
-	assert.rejects(async () => {
+	await assert.rejects(async () => {
 		let pipeline = pipe([
 			fromIterable([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]),
 			fromNodeStream(new stream.Transform({
@@ -116,6 +178,18 @@ test("transform stream, parallel", async () => {
 });
 
 /* FIXME: Do network socket test with both happy abort and error abort */
+/* TODO: Flaky test behaviour was observed for the below test:
+
+	✖ network socket (9.891608ms)
+	AssertionError [ERR_ASSERTION]: Expected values to be strictly deep-equal:
+	+ actual - expected
+	
+	+ Buffer(0) [Uint8Array] []
+	- Buffer(2) [Uint8Array] [
+	-   99,
+	-   100
+	- ]
+*/
 test("network socket", async () => {
 	let { resolve, promise } = pDefer();
 
@@ -157,3 +231,50 @@ test("network socket", async () => {
 		server.close();
 	}
 });
+
+async function wait10() {
+	await new Promise((resolve) => setTimeout(resolve, 10));
+}
+
+test("network socket with error abort", { timeout: 500 }, async () => {
+	let { resolve, promise } = pDefer();
+
+	let server = net.createServer((socket) => {
+		let serverRead = fromNodeStream.fromReadable(socket);
+		let serverWrite = fromNodeStream.fromWritable(socket);
+		resolve({ serverRead, serverWrite });
+	});
+	server.listen(14292);
+
+	try {
+		let client = net.connect({ host: "localhost", port: 14292 });
+		let clientRead = fromNodeStream.fromReadable(client);
+		let clientWrite = fromNodeStream.fromWritable(client);
+		let { serverRead, serverWrite } = await promise;
+		
+		let serverPipe = pipe([ serverRead, collect() ]);
+		let serverWritePipe = pipe([
+			fromIterable([ Buffer.from("c"), Buffer.from("d") ]),
+			testAbort(0, new Error("sample error")),
+			serverWrite
+		]);
+
+		let clientPipe = pipe([ clientRead, collect() ]);
+		let clientWritePipe = pipe([
+			fromIterable([ Buffer.from("a"), Buffer.from("b") ]),
+			/* Give the client side some time to notice that the server side closed the connection */
+			spy(async(value) => { await wait10(); return value; }),
+			clientWrite
+		]);
+
+		let results = await Promise.all([
+			assert.rejects(() => serverPipe.read(), { message: "sample error" }),
+			assert.rejects(() => serverWritePipe.read(), { message: "sample error" }),
+			/* The other side of the connection closes normally, like it would for any disconnection */
+			clientPipe.read(),
+			clientWritePipe.read(),
+		]);
+	} finally {
+		server.close();
+	}
+});