docs: writable streams from async iterators example issue

[ronag]

Given the example from https://nodejs.org/api/stream.html#stream_piping_to_writable_streams_from_async_iterators.

There is a problem where this can cause an unhandled exception if the writable emits an 'error' before the first chunk arrives from the iterator, e.g. if writable is a fs stream and it fails while opening the file.

  const writable = fs.createWriteStream('./file');

  for await (const chunk of iterator) {
    // Handle backpressure on write().
    if (!writable.write(chunk))
      await once(writable, 'drain');
  }
  writable.end();
  // Ensure completion without errors.
  await finished(writable);

[ronag]

@mcollina / @nodejs/streams: I can't think of a elegant way to resolve this. Any ideas?

Otherwise, I would suggest we remove this example until we find a better way in order to avoid people using this pattern and thinking it's safe.

[ronag]

Maybe?

EDIT: Or rather maybe not :D

  const writable = fs.createWriteStream('./file');

  // catch 'error' while not writing
  // EDIT: add a noop .catch to avoid unhandledRejection before awaiting.
  const finishedPromise = finished(writable).catch(() => {}); 
  for await (const chunk of iterator) {
    if (writable.destroyed) // assumes destroy() on 'error'
      break;

    // Handle backpressure on write().
    if (!writable.write(chunk))
      await once(writable, 'drain');
  }
  writable.end();
  // Ensure completion without errors.
  await finishedPromise;

[himself65]

what is the const finishedPromise = finished(writable); meaning? 🤔

[ronag]

what is the const finishedPromise = finished(writable); meaning? 🤔

it returns a promise that will resolve or reject when the writable finishes or errors.

Actually, that won't work either since we currently do unhandled rejection for rejected promises without a catch.

[ronag]

@himself65: "Fixed". It's not good though. Maybe not that one.

[ronag]

Another try. What if we use some kind of event that signals that no error can occur until a write is issued?

  const writable = fs.createWriteStream('./file');

  await once(writable, 'ready');
  // No error possible until writable.write

  for await (const chunk of iterator) {
    // Handle backpressure on write().
    if (!writable.write(chunk))
      await once(writable, 'drain');
  }
  writable.end();
  // Ensure completion without errors.
  await finished(writable).catch(() => {}); 

Though unfortunately, that does not exist currently. Probably also not possible to enforce since one can call .destroy(err) at any time. I don't like this either...