Proposal: add _flush to Writable streams

[markstos]

@TomFrost made a good case for this pre-fork:

nodejs/node-v0.x-archive#7631

There was also significant discussion previously in this issue:
nodejs/node-v0.x-archive#7348

@TomFrost also implemented a workaround that is published on npmjs.org:

https://www.npmjs.com/package/flushwritable

Perhaps it will be helpful in considering the issue.

I'm one of the other developers from the previous thread that would also find it to be useful.

[calvinmetcalf]

This is something I've needed and had to implement my own half baked
implementation. I'd be happy to champion this (do we do that?)

On Thu, Feb 12, 2015, 11:57 AM Mark Stosberg notifications@github.com
wrote:

@TomFrost https://github.com/TomFrost made a good case for this
pre-fork:

nodejs/node-v0.x-archive#7631 nodejs/node-v0.x-archive#7631

There was also significant discussion previously in this issue:
nodejs/node-v0.x-archive#7348 nodejs/node-v0.x-archive#7348

@TomFrost https://github.com/TomFrost also implemented a workaround
that is published on npmjs.org:

https://www.npmjs.com/package/flushwritable

Perhaps it will be helpful in considering the issue.

I'm one of the other developers from the previous thread that would also
find it to be useful.

—
Reply to this email directly or view it on GitHub
#112.

[domenic]

+1, got one of these in WHATWG streams already (under the name "close", although now I am contemplating whether flush is nicer).

[calvinmetcalf]

The tricky thing is that transform flush is after writable half has
finished but before the readable one is finished. For writable ones we'd
need it to be earlier so either a breaking change or a different name like
close.

On Thu, Feb 12, 2015, 12:52 PM Domenic Denicola notifications@github.com
wrote:

+1, got one of these in WHATWG streams already (under the name "close",
although now I am contemplating whether flush is nicer).

—
Reply to this email directly or view it on GitHub
#112 (comment)
.

[chrisdickinson]

@calvinmetcalf I'm a little confused by:

The tricky thing is that transform flush is after writable half has finished but before the readable one is finished.

My impression is that we would preserve and extend this behavior to Writables as well. Am I misunderstanding?

I am also curious: what is the order of events?

1. emit prefinish
2. _flush
3. emit finish

OR:

1. emit _flush
2. prefinish
3. emit finish

[vkurchatkin]

My impression is that we would preserve and extend this behavior to Writables as well. Am I misunderstanding?

there is no point in flushing writable after finish. the whole idea is to defer finish

[calvinmetcalf]

@chrisdickinson like @vkurchatkin said we want to defer finish, adding in new function (like calling it close) that fires earlier would likely be the only backwards compatible way to do it, we could leave _flush in but depreciate it.

[vkurchatkin]

@calvinmetcalf I was thinking about _finish. I want _close to be used to close underlying resource after finish.

[sonewman]

I am not that opinionated about this. Is there any reason why we couldn't move it from transform?

[calvinmetcalf]

@vkurchatkin I was assuming closing resources would be a use case for this

@sonewman because the transform one happens after finish is emitted and we'd want it to delay finish being emitted.

[mafintosh]

Why not call it ._end?
Similar to how .write calls ._write internally .end would call ._end before emitting finish

[calvinmetcalf]

@mafintosh and then simply end when passing it to the simplified constructor

[mafintosh]

@calvinmetcalf yea! and transforms would support both flush and end (different use cases). i know this would simplify a lot of my code.

[sonewman]

@calvinmetcalf prefinish is emitted before finish

function prefinish(stream, state) {
  if (!state.prefinished) {
    state.prefinished = true;
    stream.emit('prefinish');
  }
}

function finishMaybe(stream, state) {
  var need = needFinish(stream, state);
  if (need) {
    if (state.pendingcb === 0) {
      prefinish(stream, state);
      state.finished = true;
      stream.emit('finish');
    } else
      prefinish(stream, state);
  }
  return need;
}

lib/_stream_writable.js#L464-L482