@promistream/from-node-stream 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promistream/from-node-stream",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "main": "src/index.js",
   "repository": {
     "type": "git",

package/src/index.js

@@ -36,6 +36,12 @@ function wireReadable(debug, stream) {
 	let buffer = pushBuffer({ mode: "push" });
 	let isPaused = false;
 	let abortSeen = false;
+	let endError;
+
+	function finishStream(error) {
+		endError = error;
+		buffer.pushError(error);
+	}
 
 	stream.on("data", (value) => {
 		debug("Received value from underlying Readable stream");
@@ -58,13 +64,14 @@ function wireReadable(debug, stream) {
 		if (!abortSeen) {
 			debug(`Underlying Readable stream produced an error: ${error.message}`);
 			abortSeen = true;
-			buffer.pushError(ensureValidError(error));
+			finishStream(ensureValidError(error));
 		}
 	});
 
 	stream.on("end", () => {
+		// TODO: How/where do we propagate Aborted markers, especially on subsequent overreads?
 		debug("Reached end of underlying Readable stream");
-		buffer.pushError(new EndOfStream("The underlying stream has ended"));
+		finishStream(new EndOfStream("The underlying stream has ended"));
 	});
 
 	return {
@@ -72,11 +79,16 @@ function wireReadable(debug, stream) {
 		read: async function () {
 			let promise = buffer.request();
 
-			// We have run out of values
-			if (isPaused && buffer.countLane().requests > 0) {
-				debug("Resuming underlying Readable stream, as our buffer ran out");
-				isPaused = false;
-				stream.resume();
+			let counts = buffer.countLane();
+			if (counts.requests > 0 && counts.values === 0) {
+				// We have run out of values
+				if (endError != null) {
+					buffer.pushError(endError);
+				} else if (isPaused) {
+					debug("Resuming underlying Readable stream, as our buffer ran out");
+					isPaused = false;
+					stream.resume();
+				}
 			}
 
 			return promise;

package/test.js

@@ -177,6 +177,48 @@ test("transform stream, parallel", async () => {
 	assert.deepStrictEqual(result, [ 0, 0, 1, 2, 2, 4, 3, 6, 4, 8, 5, 10, 6, 12, 7, 14, 8, 16, 9, 18, 10, 20 ]);
 });
 
+test("transform stream, overread", { timeout: 500 }, async () => {
+	let pipeline = pipe([
+		fromIterable([ 0 ]),
+		fromNodeStream(new stream.Transform({
+			objectMode: true,
+			transform(chunk, _encoding, callback) {
+				setTimeout(() => {
+					this.push(chunk);
+					this.push(chunk * 2);
+					callback();
+				}, 10);
+			}
+		}))
+	]);
+
+	assert.strictEqual(await pipeline.read(), 0);
+	assert.strictEqual(await pipeline.read(), 0);
+	await assert.rejects(() => pipeline.read(), { name: "EndOfStream" });
+	await assert.rejects(() => pipeline.read(), { name: "EndOfStream" }); /* This should repeat the last error, just like a normal source stream would */
+});
+
+test("transform stream, abort overread", { timeout: 500 }, async () => {
+	let pipeline = pipe([
+		fromIterable([ 0 ]),
+		testAbort(0, new Error("sample error")),
+		fromNodeStream(new stream.Transform({
+			objectMode: true,
+			transform(chunk, _encoding, callback) {
+				setTimeout(() => {
+					this.push(chunk);
+					this.push(chunk * 2);
+					callback();
+				}, 10);
+			}
+		}))
+	]);
+
+	/* Since we're reading directly from the pipeline, we will get an Aborted marker in both cases; it is normally the sink stream that is responsible for unpacking and throwing the original cause, but we don't have a sink stream in this case. */
+	await assert.rejects(() => pipeline.read(), { name: "Aborted", message: "Stream was aborted due to error: sample error" });
+	await assert.rejects(() => pipeline.read(), { name: "Aborted", message: "Stream was aborted due to error: sample error" });
+});
+
 /* FIXME: Do network socket test with both happy abort and error abort */
 /* TODO: Flaky test behaviour was observed for the below test: