@promistream/from-node-stream 0.1.3 → 0.1.4

package/README.md

@@ -4,7 +4,7 @@ TODO
 
 In Node.js streams, there is a thing called a Duplex stream. This is basically a stream that has an independent readable and writable part, that are not connected together. Like a TCP socket, for example; you send data through the writable half and receive data through the readable half - but the data you receive is not the same data as you sent.
 
-Duplex streams are really just two independent streams that are stuffed into a single object, representing a single resource, like a network socket. And this is how ppstreams treats those - as two independent streams. In Promistreams, there are no Duplex streams, so when converting a Node.js Duplex stream, you will have to do the conversion twice - once for the readable part, and once for the writable part. This can be done with the `duplexRead` and `duplexWrite` methods.
+Duplex streams are really just two independent streams that are stuffed into a single object, representing a single resource, like a network socket. And this is how Promistreams treats those - as two independent streams. In Promistreams, there are no Duplex streams, so when converting a Node.js Duplex stream, you will have to do the conversion twice - once for the readable part, and once for the writable part. This can be done with the `duplexRead` and `duplexWrite` methods.
 
 __Why does Promistreams not have Duplex streams?__ Because they're surprisingly tricky to implement. They would make the Promistreams specification a lot more complex, and make certain things impossible; for example, a sink stream (writable stream) in Promistreams can return a Promise to signify when it's completely done receiving data, but a source stream (readable stream) needs to return a Promise with the next read value! You can only return one or the other, so supporting both would involve a lot of special logic for detecting what kind of thing is being returned.
 

package/package.json

@@ -1,28 +1,36 @@
 {
   "name": "@promistream/from-node-stream",
-  "version": "0.1.3",
-  "main": "index.js",
+  "version": "0.1.4",
+  "main": "src/index.js",
   "repository": "http://git.cryto.net/promistream/from-node-stream.git",
   "author": "Sven Slootweg <admin@cryto.net>",
   "license": "WTFPL OR CC0-1.0",
   "dependencies": {
+    "@joepie91/consumable": "^1.0.1",
     "@joepie91/unreachable": "^1.0.0",
-    "@promistream/buffer": "^0.1.0",
-    "@promistream/end-of-stream": "^0.1.0",
-    "@promistream/is-end-of-stream": "^0.1.0",
-    "@promistream/pipe": "^0.1.1",
-    "@promistream/propagate-abort": "^0.1.3",
-    "@promistream/propagate-peek": "^0.1.0",
-    "@promistream/simple-sink": "^0.2.0",
-    "@promistream/simple-source": "^0.1.1",
-    "bluebird": "^3.7.2",
-    "debug": "^4.3.1",
-    "p-event": "^4.2.0",
+    "@joepie91/warning": "^1.1.0",
+    "@promistream/end-of-stream": "^0.1.2",
+    "@promistream/is-aborted": "^0.1.1",
+    "@promistream/is-end-of-stream": "^0.1.1",
+    "@promistream/propagate-abort": "^0.1.7",
+    "@promistream/propagate-peek": "^0.1.1",
+    "@promistream/simple-sink": "^0.3.2",
+    "@promistream/simple-source": "^0.1.5",
+    "debug-instanced": "^1.0.0",
+    "promisify-event": "^1.0.0",
+    "push-buffer": "^1.5.5",
+    "single-concurrent": "^1.0.0",
     "split-filter": "^1.1.3"
   },
   "devDependencies": {
-    "@promistream/buffered-map": "^0.1.0",
-    "@promistream/collect": "^0.1.1",
-    "@promistream/range-numbers": "^0.1.2"
+    "@promistream/buffered-map": "^0.1.1",
+    "@promistream/collect": "^0.1.2",
+    "@promistream/debug": "^0.1.0",
+    "@promistream/from-iterable": "^0.1.0",
+    "@promistream/map": "^0.1.5",
+    "@promistream/pipe": "^0.1.6",
+    "@promistream/range-numbers": "^0.1.2",
+    "bluebird": "^3.7.2",
+    "through2": "^4.0.2"
   }
 }

package/src/index.js

@@ -0,0 +1,278 @@
+"use strict";
+
+const simpleSink = require("@promistream/simple-sink");
+const simpleSource = require("@promistream/simple-source");
+const propagateAbort = require("@promistream/propagate-abort");
+const propagatePeek = require("@promistream/propagate-peek");
+const EndOfStream = require("@promistream/end-of-stream");
+const isEndOfStream = require("@promistream/is-end-of-stream");
+const isAborted = require("@promistream/is-aborted");
+const makeDebug = require("debug-instanced")("promistream:from-node-stream");
+
+const pushBuffer = require("push-buffer");
+const promisifyEvent = require("promisify-event");
+const singleConcurrent = require("single-concurrent");
+const warning = require("@joepie91/warning");
+const util = require("node:util");
+
+const isStdioStream = require("./is-stdio-stream");
+
+function ensureValidError(error) {
+	if (error instanceof Error) {
+		return error;
+	} else {
+		let validError = new Error(`Node stream emitted an error value that is not of Error type. Value was: ${util.inspect(error)}`);
+		validError.originalValue = error;
+		return validError;
+	}
+}
+
+function isReadableStreamEnded(stream) {
+	// FIXME: Are these the correct properties to look at, for a Readable interface?
+	return (stream.readableEnded || stream.destroyed);
+}
+
+function wireReadable(debug, stream) {
+	let buffer = pushBuffer({ mode: "push" });
+	let isPaused = false;
+	let abortSeen = false;
+
+	stream.on("data", (value) => {
+		debug("Received value from underlying Readable stream");
+		buffer.push(value);
+
+		// We have more values buffered than there are outstanding requests
+		if (buffer.countLane().values > 0) {
+			debug("Pausing underlying Readable stream; enough values in our buffer already");
+
+			if (stream.pause != null) {
+				isPaused = true;
+				stream.pause();
+			} else {
+				warning("The stream you are converting does not support pausing. This may lead to unexpectedly high memory usage!");
+			}
+		}
+	});
+
+	stream.on("error", (error) => {
+		if (!abortSeen) {
+			debug(`Underlying Readable stream produced an error: ${error.message}`);
+			abortSeen = true;
+			buffer.pushError(ensureValidError(error));
+		}
+	});
+
+	stream.on("end", () => {
+		debug("Reached end of underlying Readable stream");
+		buffer.pushError(new EndOfStream("The underlying stream has ended"));
+	});
+
+	return {
+		buffer: buffer,
+		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");
+				stream.resume();
+			}
+
+			return promise;
+		},
+		abort: async function (error) {
+			if (!isStdioStream(stream) && !isReadableStreamEnded(stream)) {
+				debug("Aborting underlying Readable stream via .destroy...");
+				abortSeen = true;
+				stream.destroy(error);
+			}
+		}
+	};
+}
+
+function convertFromReadable(stream) {
+	/* Node Readable -> Promistream source
+	 * let Readable emit data events and buffer them up on Promistream side,
+	 * pausing the Node side if necessary
+	 */
+
+	let debug = makeDebug("readable");
+
+	let { read, abort } = wireReadable(debug, stream);
+
+	return simpleSource({
+		onRequest: () => {
+			return read();
+		},
+		onAbort: () => {
+			return abort();
+		}
+	});
+}
+
+function isWritableStreamEnded(stream) {
+	// TODO: Is this correct? In the old version, we were looking at stream.closed instead. Original comment related to that:
+	// 			> When a writable stream has emitted its 'close' event, it no longer produces errors and will behave as if it's perpetually backlogged
+	// 			> Ref: https://github.com/nodejs/node/issues/53512
+	return (stream.writableEnded || stream.destroyed);
+}
+
+function wireWritable(debug, stream) {
+	let errorEncountered;
+
+	stream.on("error", (error) => {
+		debug("Logging writable interface error:", error);
+		errorEncountered = ensureValidError(error);
+	});
+
+	// We're not wiring into the `finish` event here because we detect the ended stream on the next write attempt instead (inside of `tryWrite`).
+
+	return {
+		destroy: async function (error) {
+			// TODO: Do we need to detach any event handlers prior to destroying streams? ref. https://www.npmjs.com/package/yauzl:
+			//   "You must unpipe() the readStream from any destination before calling readStream.destroy()."
+			// TODO: In a previous version, we skipped the .destroy step if the stream didn't have a .destroy method. What was this for? Streams v1?
+			if (!isStdioStream(stream) && !isWritableStreamEnded(stream)) {
+				debug("Calling .destroy on Writable stream");
+				stream.destroy(error);
+			}
+		},
+		end: async function () {
+			if (!isStdioStream(stream) && !isWritableStreamEnded(stream)) {
+				debug("Calling .end on Writable stream");
+				stream.end();
+			}
+		},
+		tryWrite: async function (value, abort) {
+			if (isWritableStreamEnded(stream)) {
+				debug("Could not write because underlying stream has ended");
+				if (errorEncountered != null) {
+					debug("... due to an error");
+					abort(errorEncountered);
+				} else {
+					debug("... due to its completion");
+					abort(true);
+				}
+			} else {
+				// TODO: Old version had a special case for stdio streams, using the flush callback argument to .write to know when the next write could be done; because according to the stream-to-pull-stream package's code, the `drain` event does not work correctly there. Need to investigate whether this is still true!
+				// FIXME: Validate `value`. When the target of the write is process.stdout (presumably any text stream), writing `undefined` is not allowed. May not be allowed for object streams either; need to investigate. This should raise an explicit and clear error.
+				let canWriteMore = stream.write(value);
+
+				if (!canWriteMore) {
+					debug("Stream is backlogged, waiting for drain event...");
+					await promisifyEvent(stream, "drain");
+					debug("Drain event received");
+				} else {
+					debug("Write successful, can write more");
+				}
+			}
+		}
+	};
+}
+
+function convertFromWritable(stream) {
+	/* Node Writable -> Promistream sink
+	 * Promistream side continuously requests reads until Node side is corked
+	 */
+
+	let debug = makeDebug("writable");
+
+	let { destroy, end, tryWrite } = wireWritable(debug, stream);
+
+	return simpleSink({
+		onAbort: async (error) => {
+			if (error === true) {
+				return end();
+			} else {
+				return destroy(error);
+			}
+		},
+		onEnd: async () => {
+			return end();
+		},
+		onValue: async (value, abort) => {
+			return tryWrite(value, abort);
+		}
+	});
+}
+
+function convertFromTransform(stream) {
+	let debug = makeDebug("transform");
+
+	let { buffer, read } = wireReadable(debug, stream);
+	let { destroy, end, tryWrite } = wireWritable(debug, stream);
+
+	/* while the promistream upstream has not been ended or aborted, keep reading from it and writing into tryWrite (relying on it to provide backpressure via promises). make sure that an error propagates on the next read (insert into read buffer). meanwhile for every own-promistream read request, schedule a buffer read on the readable interface. */
+
+	let lastSource, endMarker;
+
+	let tryFeedStream = singleConcurrent(async () => {
+		// This is essentially a 'background process' of sorts, with manual error handling wiring.
+		try {
+			while (endMarker == null) {
+				await tryWrite(await lastSource.read());
+			}
+		} catch (error) {
+			if (endMarker == null && (isEndOfStream(error) || isAborted(error))) {
+				endMarker = error;
+
+				// TODO: Is this necessary? Is this not already handled by wiring for the readable/writable interface?
+				if (isAborted(error)) {
+					if (error.cause instanceof Error) {
+						destroy(error);
+					} else {
+						// Normally ended
+						end();
+					}
+				} else if (isEndOfStream(error)) {
+					end();
+				}
+			}
+
+			buffer.pushError(error);
+		}
+	});
+
+	return {
+		_promistreamVersion: 0,
+		description: `Node.js transform stream`,
+		abort: propagateAbort,
+		peek: propagatePeek,
+		read: async function produceValue_transformStream(source) {
+			lastSource = source;
+			tryFeedStream();
+			return read();
+		}
+	};
+}
+
+function convert(stream) {
+	// FIXME: Proper validation and tagging?
+	// TODO: Wrap v1 streams to support them
+	// NOTE: Standard I/O streams are specialcased here because they may be Duplex streams; even though the other half is never actually used. We're only interested in the interface that *is* being used.
+	if (stream === process.stdin) {
+		return convertFromReadable(stream);
+	} else if (stream === process.stdout || stream === process.stderr) {
+		return convertFromWritable(stream);
+	} else if (stream.writable != null) {
+		if (stream.readable != null) {
+			if  (stream._transform != null) {
+				// transform
+				return convertFromTransform(stream);
+			} else {
+				throw new Error(`Duplex streams cannot be converted with the auto-detection API. Instead, use 'fromReadable' and/or 'fromWritable' manually, depending on which parts of the Duplex stream you are interested in.`);
+			}
+		} else {
+			return convertFromWritable(stream);
+		}
+	} else if (stream.readable != null) {
+		return convertFromReadable(stream);
+	} else {
+		throw new Error(`Not a Node stream`);
+	}
+}
+
+module.exports = convert;
+module.exports.fromReadable = convertFromReadable;
+module.exports.fromWritable = convertFromWritable;
+module.exports.fromTransform = convertFromTransform;

package/test.js

@@ -0,0 +1,67 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert");
+const fs = require("node:fs");
+const path = require("node:path");
+const stream = require("node:stream");
+
+const pipe = require("@promistream/pipe");
+const fromIterable = require("@promistream/from-iterable");
+const fromNodeStream = require(".");
+const collect = require("@promistream/collect");
+const debug = require("@promistream/debug");
+
+test("readable stream", async () => {
+	let testFile = path.join(__dirname, "pnpm-lock.yaml"); // Big-ish file, so we're likely to read in multiple chunks
+	let expected = await fs.promises.readFile(testFile);
+
+	let result = await pipe([
+		fromNodeStream.fromReadable(fs.createReadStream(testFile)),
+		collect()
+	]).read();
+
+	assert.deepStrictEqual(result, [ expected ]);	
+});
+
+test("writable stream", 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 pipe([
+		fromIterable([ buffer, buffer, buffer ]),
+		fromNodeStream(nodeWritable)
+	]).read();
+
+	assert.strictEqual(writableBuffer.length, 400000 * 3);
+	assert.strictEqual(endReached, true);
+});
+
+test("transform stream", async () => {
+	let result = await pipe([
+		fromIterable([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]),
+		fromNodeStream(new stream.Transform({
+			objectMode: true,
+			transform(chunk, _encoding, callback) {
+				this.push(chunk);
+				this.push(chunk * 2);
+				callback();
+			}
+		})),
+		collect()
+	]).read();
+
+	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 ]);
+});

package/index.js

@@ -1,178 +0,0 @@
-"use strict";
-
-const Promise = require("bluebird");
-const simpleSource = require("@promistream/simple-source");
-const simpleSink = require("@promistream/simple-sink");
-const buffer = require("@promistream/buffer");
-const propagatePeek = require("@promistream/propagate-peek");
-const propagateAbort = require("@promistream/propagate-abort");
-const pipe = require("@promistream/pipe");
-const isEndOfStream = require("@promistream/is-end-of-stream");
-const debug = require("debug");
-
-const createDefer = require("./src/create-defer");
-const wireUpReadableInterface = require("./src/readable");
-const wireUpWritableInterface = require("./src/writable");
-
-// FIXME: Maybe also an abstraction for 'handle queue of requests', as this is used in multiple stream implementations
-// TODO: Improve robustness of stream-end handling using https://nodejs.org/dist/latest-v14.x/docs/api/stream.html#stream_stream_finished_stream_options_callback?
-// FIXME: Sequentialize all of these?
-
-// readable
-// writable
-// transform
-// duplex
-
-module.exports = function convert(stream) {
-	// FIXME: Proper validation and tagging
-	// FIXME: Wrap v1 streams
-	// NOTE: Standard I/O streams are specialcased here because they may be Duplex streams; even though the other half is never actually used. We're only interested in the interface that *is* being used.
-	if (stream === process.stdin) {
-		return fromReadable(stream);
-	} else if (stream === process.stdout || stream === process.stderr) {
-		return fromWritable(stream);
-	} else if (stream.writable != null) {
-		if (stream.readable != null) {
-			if  (stream._transform != null) {
-				// transform
-				return fromTransform(stream);
-			} else {
-				throw new Error(`Duplex streams cannot be converted with the auto-detection API. Instead, use 'fromReadable' and/or 'fromWritable' manually, depending on which parts of the Duplex stream you are interested in.`);
-			}
-		} else {
-			return fromWritable(stream);
-		}
-	} else if (stream.readable != null) {
-		return fromReadable(stream);
-	} else {
-		throw new Error(`Not a Node stream`);
-	}
-};
-
-function fromReadable(stream) {
-	let readable = wireUpReadableInterface(stream);
-
-	return simpleSource({
-		onRequest: () => {
-			return readable.request();
-		},
-		onAbort: () => {
-			return readable.destroy();
-		}
-	});
-}
-
-let debugWritable = debug("promistream:from-node-stream:writable");
-
-function fromWritable(stream) {
-	let upstreamHasEnded = false;
-	let mostRecentSource = { abort: function() {} }; // FIXME: Replace with a proper spec-compliant dummy stream
-
-	let convertedStream = simpleSink({
-		onResult: (result) => {
-			debugWritable("Received value");
-			return writable.write(result);
-		},
-		onEnd: () => {
-			debugWritable("Upstream reported end-of-stream");
-			upstreamHasEnded = true;
-			return writable.end();
-		},
-		onAbort: (_reason) => {
-			debugWritable("Pipeline was aborted");
-			return writable.destroy();
-		},
-		onSourceChanged: (source) => {
-			debugWritable("A source change occurred");
-			mostRecentSource = source;
-		}
-	});
-
-	// NOTE: The use of `var` is intentional, to make hoisting possible here; otherwise we'd have a broken cyclical reference
-	var writable = wireUpWritableInterface(stream, {
-		onEnd: () => {
-			debugWritable(`Underlying stream has reported a close event (upstreamHasEnded = ${upstreamHasEnded})`);
-
-			if (!upstreamHasEnded) {
-				debugWritable(`Issuing happy abort on converted stream`);
-				convertedStream.abort(true, mostRecentSource);
-			}
-		},
-		onError: (error) => {
-			// Make sure we notify the pipeline, if any, by passing in the most recent source stream that we've seen.
-			debugWritable(`Issuing error abort on converted stream due to: ${error.message}`);
-			convertedStream.abort(error, mostRecentSource);
-		}
-	});
-
-	return convertedStream;
-}
-
-let debugTransform = debug("promistream:from-node-stream:transform");
-
-function fromTransform(stream) {
-	let endHandled = false;
-
-	// FIXME: we need to specifically watch for the `error` and `end` events on the readable interface, to know when the transform stream has fully completed processing
-	// 		Respond to the EndOfStream produced by the pushbuffer in this case
-	// request, destroy
-	let readable = wireUpReadableInterface(stream, {
-		onEnd: () => {
-			debugTransform("Received end/close event from underlying stream");
-		},
-		onError: () => {
-			debugTransform("Received error event from underlying stream");
-		}
-	});
-
-	// write, end, destroy
-	let writable = wireUpWritableInterface(stream);
-
-	let convertedStream = {
-		_promistreamVersion: 0,
-		description: `converted Node.js transform stream`,
-		abort: propagateAbort,
-		peek: propagatePeek,
-		read: function produceValue_nodeTransformStream(source) {
-			if (endHandled) {
-				// NOTE: This logic exists at the start, not in the upstream EndOfStream handling code, because any number of buffer reads may be required before the wrapped Node stream can be closed
-				// NOTE: The push-buffer will automatically produce EndOfStream markers once the buffer has run out and the underlying stream has closed, so long as we're using the wireUpReadableInterface function
-				// FIXME: Refactor this design to request-matcher instead?
-				return Promise.try(() => {
-					return readable.request();
-				}).then((result) => {
-					return [ result ];
-				});
-			} else {
-				return Promise.try(() => {
-					debugTransform("Doing upstream read...");
-					return source.read();
-				}).then((value) => {
-					debugTransform("Writing upstream value to writable interface");
-					writable.write(value);
-
-					// This will quite possibly return an empty buffer, but that is fine; the `buffer` stream downstream from us will just keep reading (and therefore queueing up new items to be transformed) until it gets some results.
-					debugTransform("Consuming immediate buffer from readable interface");
-					return readable.consumeImmediateBuffer();
-				}).catch(isEndOfStream, () => {
-					debugTransform("End of upstream reached");
-					endHandled = true;
-
-					debugTransform("Closing via writable interface");
-					writable.end();
-
-					// Return nothing, let the next read call (and all of those after that) deal with either underlying stream completion or buffered results
-					return [];
-				});
-			}
-		}
-	};
-
-	return pipe([
-		convertedStream,
-		buffer()
-	]);
-}
-
-module.exports.fromReadable = fromReadable;
-module.exports.fromWritable = fromWritable;

package/src/assert-error-type.js

@@ -1,16 +0,0 @@
-"use strict";
-
-const util = require("util");
-
-module.exports = function assertErrorType(error) {
-	if (!(error instanceof Error)) {
-		let stack = (new Error).stack
-			.split("\n")
-			.filter((line, n) => (n > 0 || !line.startsWith("Error")))
-			.join("\n");
-
-		console.warn(`Converted Node stream produced an error value that isn't an Error instance: ${util.inspect(error)}`);
-		console.warn(`Stack:`);
-		console.warn(stack);
-	}
-};

package/src/create-defer.js

@@ -1,20 +0,0 @@
-"use strict";
-
-// FIXME: Can we use p-defer here instead?
-module.exports = function createDefer() {
-	let resolveFunc, rejectFunc;
-
-	// NOTE: This works because the `new Promise` callback gets executed synchronously.
-	let promise = new Promise((resolve, reject) => {
-		resolveFunc = resolve;
-		rejectFunc = reject;
-	});
-
-	return {
-		promise: promise,
-		defer: {
-			resolve: resolveFunc,
-			reject: rejectFunc
-		}
-	};
-};

package/src/destroy-stream.js

@@ -1,11 +0,0 @@
-"use strict";
-
-const warn = require("./warn");
-
-module.exports = function destroyStream(stream) {
-	if (typeof stream.destroy === "function") {
-		stream.destroy();
-	} else {
-		warn("The stream you are converting does not have a 'destroy' method, and could therefore not be destroyed. This may cause resource leaks!");
-	}
-};

package/src/readable/attach-handlers.js

@@ -1,35 +0,0 @@
-"use strict";
-
-const debug = require("debug")("promistream:from-node-stream:readable:attach-handlers");
-
-module.exports = function attachReadableStreamHandlers({ stream, onClose, onError, onData }) {
-	function detachEventHandlers() {
-		debug("Detaching event handlers");
-		stream.removeListener("end", onCloseWrapper);
-		stream.removeListener("close", onCloseWrapper);
-		stream.removeListener("error", onErrorWrapper);
-		stream.removeListener("data", onData);
-	}
-
-	function attachEventHandlers() {
-		debug("Attaching event handlers");
-		stream.on("end", onCloseWrapper);
-		stream.on("close", onCloseWrapper);
-		stream.on("error", onErrorWrapper);
-		stream.on("data", onData);
-	}
-
-	function onCloseWrapper() {
-		debug("onCloseWrapper called");
-		onClose();
-		detachEventHandlers();
-	}
-
-	function onErrorWrapper(error) {
-		debug("onErrorWrapper called");
-		onError(error);
-		detachEventHandlers();
-	}
-
-	attachEventHandlers();
-};

package/src/readable/index.js

@@ -1,68 +0,0 @@
-"use strict";
-
-const debug = require("debug")("promistream:from-node-stream:readable");
-
-const attachHandlers = require("./attach-handlers");
-const createPushBuffer = require("./push-buffer");
-const destroyStream = require("../destroy-stream");
-const assertErrorType = require("../assert-error-type");
-
-module.exports = function wireUpReadableInterface(stream, { onEnd, onError } = {}) {
-	let pushBuffer = createPushBuffer({
-		onPause: function () {
-			if (stream.pause != null) {
-				debug("Pausing underlying stream");
-				stream.pause();
-				return true; // FIXME: Can we verify whether the pausing was successful, somehow? Eg. to deal with streams with `readable` event handlers attached.
-			} else {
-				return false;
-			}
-		},
-		onResume: function () {
-			if (stream.resume != null) {
-				debug("Resuming underlying stream");
-				stream.resume();
-				return true;
-			} else {
-				throw new Error(`Stream was successfully paused but does not have a resume method. This should never happen!`);
-			}
-		}
-	});
-
-	// TODO: Verify that auto-detaching all event handlers upon end/error is actually the correct thing to do!
-	attachHandlers({
-		stream: stream,
-		onData: (data) => {
-			if (Buffer.isBuffer(data)) {
-				debug(`Chunk emitted of length ${data.length}`);
-			} else {
-				debug(`Value emitted`);
-			}
-
-			pushBuffer.queueValue(data);
-		},
-		onError: (error) => {
-			assertErrorType(error);
-			pushBuffer.queueError(error);
-			
-			if (onError != null) {
-				onError(error);
-			}
-		},
-		onClose: () => {
-			pushBuffer.markEnded();
-			
-			if (onEnd != null) {
-				onEnd();
-			}
-		}
-	});
-
-	return {
-		request: pushBuffer.queueRequest,
-		consumeImmediateBuffer: pushBuffer.consumeImmediateBuffer,
-		destroy: () => {
-			return destroyStream(stream);
-		}
-	};
-};

package/src/readable/push-buffer.js

@@ -1,143 +0,0 @@
-"use strict";
-
-// FIXME: Separate this out into its own package
-
-const splitFilter = require("split-filter");
-const unreachable = require("@joepie91/unreachable")("@promistream/from-node-stream");
-const EndOfStream = require("@promistream/end-of-stream");
-const debug = require("debug")("promistream:from-node-stream:push-buffer");
-
-const warn = require("../warn");
-const createDefer = require("../create-defer");
-
-module.exports = function createPushBuffer(options) {
-	let onPause = options.onPause || function pauseNotImplemented() {
-		return false;
-	};
-
-	let onResume = options.onResume || function resumeNotImplemented() {
-		return false;
-	};
-
-	// TODO: Use @joepie91/consumable here?
-	let itemBuffer = [];
-	let requestQueue = [];
-	let isPaused = false;
-	let hasEnded = false;
-
-	function resumeIfEmpty() {
-		let bufferIsEmpty = (itemBuffer.length === 0);
-
-		if (bufferIsEmpty && isPaused) {
-			if (onResume() === true) {
-				isPaused = false;
-			}
-		}
-	}
-
-	function attemptDrain() {
-		// NOTE: This must remain fully synchronous, if we want to avoid unnecessary pauses in the `data` handler
-		debug("Drain attempt started");
-
-		if (requestQueue.length > 0) {
-			while (requestQueue.length > 0) {
-				let hasItems = (itemBuffer.length > 0);
-				let hasResponse = (hasEnded || hasItems);
-
-				if (hasResponse) {
-					debug("Satisfying queued request");
-					let defer = requestQueue.shift();
-
-					if (hasItems) {
-						// FIXME: Does this correctly deal with an error event produced as a result of an abort?
-						let item = itemBuffer.shift();
-
-						if (item.type === "value") {
-							defer.resolve(item.value);
-						} else if (item.type === "error") {
-							defer.reject(item.error);
-						} else {
-							unreachable(`Unexpected item type '${item.type}'`);
-						}
-					} else if (hasEnded) {
-						defer.reject(new EndOfStream());
-					} else {
-						unreachable("Invalid response state, neither has items in queue nor ended");
-					}
-				} else {
-					debug("No data available to satisfy queued request");
-					break;
-				}
-			}
-		} else {
-			debug("No outstanding requests to satisfy");
-		}
-
-		resumeIfEmpty();
-	}
-
-	return {
-		queueValue: function (value) {
-			debug("Queueing value");
-			itemBuffer.push({ type: "value", value: value });
-			attemptDrain();
-
-			let stillHasItemsBuffered = (itemBuffer.length > 0);
-
-			if (stillHasItemsBuffered && !isPaused) {
-				if (onPause() === true) {
-					isPaused = true;
-				} else {
-					// FIXME: Only show this warning once?
-					warn("The stream you are converting does not support pausing. This may lead to unexpectedly high memory usage!");
-				}
-			}
-		},
-		queueError: function (error) {
-			debug("Queueing error");
-			itemBuffer.push({ type: "error", error: error });
-			attemptDrain();
-		},
-		queueRequest: function () {
-			debug("Queueing read request");
-			let { defer, promise } = createDefer();
-			requestQueue.push(defer);
-			attemptDrain();
-			return promise;
-		},
-		markEnded: function () {
-			debug("Marking as ended");
-			hasEnded = true;
-			attemptDrain();
-		},
-		consumeImmediateBuffer: function () {
-			debug("Post-drain remaining buffer requested");
-			attemptDrain();
-
-			debug("Returning immediate buffer");
-
-			// FIXME: Only return successful items here?
-			if (requestQueue.length > 0) {
-				// We won't ever serve up the buffer until any individual-item requests have been fulfilled.
-				return [];
-			} else {
-				let [ values, errors ] = splitFilter(itemBuffer, (item) => item.type === "value");
-
-				debug(`Buffer contains ${errors.length} errors and ${values.length} values`);
-
-				if (errors.length > 0) {
-					debug("Throwing first error");
-
-					itemBuffer = values; // In case we ever write code that will do something with the remaining values in the buffer
-					throw errors[0].error;
-				} else {
-					debug(`Returning ${values.length} values`);
-
-					itemBuffer = [];
-					resumeIfEmpty(); // Ensure that we haven't left the source stream in a paused state, because that would deadlock the pipeline
-					return values.map((item) => item.value);
-				}
-			}
-		}
-	};
-};

package/src/warn.js

@@ -1,5 +0,0 @@
-"use strict";
-
-module.exports = function warn(message) {
-	console.error(`[@promistream/from-node-stream] Warning: ${message}`);
-};

package/src/writable/attach-handlers.js

@@ -1,27 +0,0 @@
-"use strict";
-
-module.exports = function attachWritableStreamHandlers({ stream, onClose, onError }) {
-	function detachEventHandlers() {
-		stream.removeListener("finish", onCloseWrapper);
-		stream.removeListener("close", onCloseWrapper);
-		stream.removeListener("error", onErrorWrapper);
-	}
-
-	function attachEventHandlers() {
-		stream.on("finish", onCloseWrapper);
-		stream.on("close", onCloseWrapper);
-		stream.on("error", onErrorWrapper);
-	}
-
-	function onCloseWrapper() {
-		onClose();
-		detachEventHandlers();
-	}
-
-	function onErrorWrapper(error) {
-		onError(error);
-		detachEventHandlers();
-	}
-
-	attachEventHandlers();
-};

package/src/writable/index.js

@@ -1,49 +0,0 @@
-"use strict";
-
-const pEvent = require("p-event");
-const debug = require("debug")("promistream:from-node-stream:writable");
-
-const attachHandlers = require("./attach-handlers");
-const writeToStream = require("./write-to-stream");
-const isStdioStream = require("../is-stdio-stream");
-const destroyStream = require("../destroy-stream");
-const assertErrorType = require("../assert-error-type");
-
-module.exports = function wireUpWritableInterface(stream, { onEnd, onError } = {}) {
-	attachHandlers({
-		stream: stream,
-		onClose: () => {
-			if (onEnd != null) {
-				onEnd();
-			}
-		},
-		onError: (error) => {
-			assertErrorType(error);
-
-			if (onError != null) {
-				onError(error);
-			}
-		}
-	});
-
-	return {
-		write: function (value) {
-			return writeToStream(stream, value);
-		},
-		end: function () {
-			// stdout/stderr cannot be ended like other streams
-			if (!isStdioStream(stream)) {
-				debug("Ending stream");
-
-				let finishPromise = pEvent(stream, "finish");
-				stream.end();
-				return finishPromise;
-			} else {
-				debug("Not ending stream because it is stdio");
-			}
-		},
-		destroy: function () {
-			return destroyStream(stream);
-		}
-	};
-};

package/src/writable/write-to-stream.js

@@ -1,33 +0,0 @@
-"use strict";
-
-const debug = require("debug")("promistream:from-node-stream:writable");
-
-const isStdioStream = require("../is-stdio-stream");
-
-module.exports = function writeToStream(stream, value) {
-	if (!isStdioStream(stream)) {
-		let canWriteMore = stream.write(value);
-		
-		if (canWriteMore) {
-			debug("Stream can accept more data");
-			return;
-		} else {
-			debug("Stream is backed up, waiting for drain event...");
-			// TODO: Use p-event instead?
-			return new Promise((resolve, _reject) => {
-				stream.once("drain", () => {
-					debug("Drain event received");
-					resolve();
-				});
-			});
-		}
-	} else {
-		// NOTE: According to the `stream-to-pull-stream` code, stdout/stderr behave differently from normal streams, and the `drain` event doesn't work correctly there. So instead, we use the flush callback to know when to write the next bit of data.
-		return new Promise((resolve, _reject) => {
-			stream.write(value, (_error) => {
-				// NOTE: We ignore any errors here, and wait for them to be thrown in the `error` event, to simplify the logic.
-				resolve();
-			});
-		});
-	}
-};