errors and async consequence

Hello,

the current API for errors is

errors(function(err, push) {})

so we can push one or more values at the current location of the stream if we already know those values.

When you need an async operation in order to know how to react to an error, how would you organize your streams ? a consume custom transform ? a sort of push(stream) + sequence

I wonder if there is room for an API of the style

errors(function(err, push, next) {})

[vqvu]

I would just use consume for this. The onError transform suggested in this issue isn’t implemented.

stream.consume((err, x, push, next) => {
  if (err) {
    // You can use toCallback if logErrorAsync must return a Highland stream,
    // and you can't access the underlying promise.
    logErrorAsync(err)
        .then(() => next())
        .catch((loggingError) => {
          push(loggingError);
          next();
        });
    push(err);
  } else {
    push(null, x);
    if (x !== _.nil) {
      next();
    }
  }
});

You can extract this into a through-transform if you need to use it in multiple places. There are examples in the docs.

[cantide5ga]

This is really old now, but exactly what I’m dealing with currently. @vqvu, @jeromew et al, what is the approach you use now-a-days?

My case is that I need to log errors in an async fashion (specifically to an AWS S3 bucket) and push the error back on the stream so that it can go and fail. Additionally, if the logging has issues, I push a new error that does a couple extra steps. The async stuff is within a promise wrapped by highland.

Is there an example in the docs of a pattern that covers this? Or alternative approaches?