Deprecate default onEnd, allow returning from onResult, refactor/fix error handling, fix duplicate onEnd calls

index.js

@@ -1,6 +1,8 @@
 "use strict";
 
 const Promise = require("bluebird");
+const createResultBuffer = require("result-buffer");
+
 const propagateAbort = require("@promistream/propagate-abort");
 const propagatePeek = require("@promistream/propagate-peek");
 const isEndOfStream = require("@promistream/is-end-of-stream");
@@ -9,7 +11,6 @@ const isAborted = require("@promistream/is-aborted");
 const { validateOptions } = require("@validatem/core");
 const required = require("@validatem/required");
 const isFunction = require("@validatem/is-function");
-const defaultTo = require("@validatem/default-to");
 const wrapValueAsOption = require("@validatem/wrap-value-as-option");
 
 // FIXME: Update other stream implementations to new API
@@ -20,20 +21,18 @@ module.exports = function simpleSinkStream(_options) {
 			onResult: [ required, isFunction ],
 			onAbort: [ isFunction ],
 			onSourceChanged: [ isFunction ],
-			onEnd: [ isFunction, defaultTo.literal(function defaultOnEnd() {
+			onEnd: [ isFunction ]
-				// FIXME: Deprecate this, it does not work as-expected when the onResult callback never gets called (eg. due to a stream immediately terminating), as the onResult callback will then never get a chance to set the lastResult, not even to an initializer value (eg. an empty array for `collect`)
-				// We return whatever value we got last from the specified onResult callback.
-				return lastResult;
-			})]
 		}
 	]);
 
-	let lastResult;
+	// FIXME: Bump minor version!
+
 	let onEndCalled = false;
-	let onEndResult;
 	let abortHandled = false;
 	let lastKnownSource;
 
+	let resultBuffer = createResultBuffer();
+
 	return {
 		_promistreamVersion: 0,
 		description: `simple sink stream`,
@@ -45,14 +44,19 @@ module.exports = function simpleSinkStream(_options) {
 					return source.read();
 				}).then((value) => {
 					// FIXME: Document that you can pause the sink from the onResult callback, by returning a Promise that resolves when it should be resumed
-					return onResult(value);
+					return onResult(value, source.abort.bind(source));
 				}).then((result) => {
-					lastResult = result;
+					// FIXME: Replace all instances of undefined checks with a standardized NoValue marker
-
+					if (result !== undefined) {
+						// TODO: Force end of stream when this occurs?
+						return result;
+					} else {
 						return attemptRead();
+					}
 				});
 			}
 
+			return resultBuffer.maybeRead(() => {
 				return Promise.try(() => {
 					if (source !== lastKnownSource && onSourceChanged != null) {
 						lastKnownSource = source;
@@ -60,19 +64,23 @@ module.exports = function simpleSinkStream(_options) {
 					}
 				}).then(() => {
 					return attemptRead();
-			}).catch(isEndOfStream, () => {
+				}).catch(isEndOfStream, (error) => {
 					/* Don't attempt to do another read, we're done.  */
-				// FIXME: Is it actually correct to keep returning the same thing?
+					if (!onEndCalled && onEnd != null) {
-				if (onEndCalled) {
+						onEndCalled = true;
-					return onEndResult;
+						
-				} else {
 						return Promise.try(() => {
 							return onEnd();
 						}).then((result) => {
-						onEndResult = result;
+							if (result !== undefined) {
-						return result;
+								resultBuffer.push(result);
+							}
 						});
 					}
+
+					return resultBuffer.maybeRead(() => {
+						throw error;
+					});
 				}).catch((error) => !isAborted(error), (error) => {
 					return Promise.try(() => {
 						return source.abort(error);
@@ -97,20 +105,24 @@ module.exports = function simpleSinkStream(_options) {
 	
 						return Promise.try(() => {
 							if (onAbort != null) {
-							return onAbort();
+								return onAbort(marker.reason);
 							}
-					}).then(() => {
+						}).then((value) => {
+							if (value !== undefined) {
+								resultBuffer.push(value);
+							}
+	
 							if (marker.reason instanceof Error) {
 								// NOTE: This ensures that the original error causing the abort is thrown exactly once
-							throw marker.reason;
+								resultBuffer.push(Promise.reject(marker.reason));
-						} else {
-							throw marker;
 							}
 						});
-				} else {
-					// Don't interfere, we only need special behaviour on the first occurrence
-					throw marker;
 					}
+	
+					return resultBuffer.maybeRead(() => {
+						throw marker;
+					});
+				});
 			});
 		}
 	};

package.json

@@ -11,10 +11,10 @@
     "@promistream/propagate-abort": "^0.1.6",
     "@promistream/propagate-peek": "^0.1.1",
     "@validatem/core": "^0.3.11",
-    "@validatem/default-to": "^0.1.0",
     "@validatem/is-function": "^0.1.0",
     "@validatem/required": "^0.1.1",
     "@validatem/wrap-value-as-option": "^0.1.0",
-    "bluebird": "^3.5.4"
+    "bluebird": "^3.5.4",
+    "result-buffer": "^0.1.0"
   }
 }