From e42af5634b4000332ce9c41a43590a1719e8659a Mon Sep 17 00:00:00 2001
From: Robert Nagy <ronagy@icloud.com>
Date: Fri, 2 Aug 2019 08:09:06 +0200
Subject: [PATCH 1/2] stream: writableEnded

---
 doc/api/stream.md                                 | 13 +++++++++++++
 lib/_stream_duplex.js                             | 10 ++++++++++
 lib/_stream_writable.js                           | 10 ++++++++++
 test/parallel/test-stream-writable-ended-state.js |  4 ++++
 4 files changed, 37 insertions(+)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index c7b00f983d83ac..8f6ade9ead2757 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -489,6 +489,17 @@ added: v11.4.0
 
 Is `true` if it is safe to call [`writable.write()`][stream-write].
 
+##### writable.writableEnded
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Is `true` after [`writable.end()`][] has been called. This property
+does not indicate whether the data has been flushed, for this use
+[`writable.writableFinished`][] instead.
+
 ##### writable.writableFinished
 <!-- YAML
 added: v12.6.0
@@ -2696,7 +2707,9 @@ contain multi-byte characters.
 [`stream.unpipe()`]: #stream_readable_unpipe_destination
 [`stream.wrap()`]: #stream_readable_wrap_stream
 [`writable.cork()`]: #stream_writable_cork
+[`writable.end()`]: #stream_writable_end_chunk_encoding_callback
 [`writable.uncork()`]: #stream_writable_uncork
+[`writable.writableFinished`]: #stream_writable_writablefinished
 [`zlib.createDeflate()`]: zlib.html#zlib_zlib_createdeflate_options
 [API for Stream Consumers]: #stream_api_for_stream_consumers
 [API for Stream Implementers]: #stream_api_for_stream_implementers
diff --git a/lib/_stream_duplex.js b/lib/_stream_duplex.js
index d20877e921e445..73033ab851a849 100644
--- a/lib/_stream_duplex.js
+++ b/lib/_stream_duplex.js
@@ -108,6 +108,16 @@ Object.defineProperty(Duplex.prototype, 'writableFinished', {
   }
 });
 
+Object.defineProperty(Duplex.prototype, 'writableEnded', {
+  // Making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get() {
+    return this._writableState.ending;
+  }
+});
+
 // The no-half-open enforcer
 function onend() {
   // If the writable side ended, then we're ok.
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index bf9abeeed81d45..5236258f77f954 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -352,6 +352,16 @@ function decodeChunk(state, chunk, encoding) {
   return chunk;
 }
 
+Object.defineProperty(Writable.prototype, 'writableEnded', {
+  // Making it explicit this property is not enumerable
+  // because otherwise some prototype manipulation in
+  // userland will fail
+  enumerable: false,
+  get: function() {
+    return this._writableState.ending;
+  }
+});
+
 Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
   // Making it explicit this property is not enumerable
   // because otherwise some prototype manipulation in
diff --git a/test/parallel/test-stream-writable-ended-state.js b/test/parallel/test-stream-writable-ended-state.js
index 69ba3c88ede253..e5fa624c12aed7 100644
--- a/test/parallel/test-stream-writable-ended-state.js
+++ b/test/parallel/test-stream-writable-ended-state.js
@@ -9,13 +9,17 @@ const writable = new stream.Writable();
 
 writable._write = (chunk, encoding, cb) => {
   assert.strictEqual(writable._writableState.ended, false);
+  assert.strictEqual(writable.writableEnded, false);
   cb();
 };
 
 assert.strictEqual(writable._writableState.ended, false);
+assert.strictEqual(writable.writableEnded, false);
 
 writable.end('testing ended state', common.mustCall(() => {
   assert.strictEqual(writable._writableState.ended, true);
+  assert.strictEqual(writable.writableEnded, true);
 }));
 
 assert.strictEqual(writable._writableState.ended, true);
+assert.strictEqual(writable.writableEnded, true);

From 1a6f945e01151d74221e91ac786953551672c7bf Mon Sep 17 00:00:00 2001
From: Robert Nagy <ronagy@icloud.com>
Date: Fri, 2 Aug 2019 08:09:13 +0200
Subject: [PATCH 2/2] http: writableEnded

---
 doc/api/http.md                               | 34 +++++++++++++++++++
 doc/api/http2.md                              | 12 +++++++
 lib/_http_outgoing.js                         |  4 +++
 lib/_stream_duplex.js                         |  8 ++---
 lib/_stream_writable.js                       |  6 ++--
 lib/internal/http2/compat.js                  |  5 +++
 .../test-http-outgoing-finish-writable.js     |  2 ++
 .../test-http2-compat-serverresponse-end.js   |  2 ++
 ...st-http2-compat-serverresponse-finished.js |  2 ++
 9 files changed, 68 insertions(+), 7 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index 62965fcea54545..14386c0778739a 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -764,6 +764,27 @@ req.once('response', (res) => {
 });
 ```
 
+### request.writableEnded
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Is `true` after [`request.end()`][] has been called. This property
+does not indicate whether the data has been flushed, for this use
+[`request.writableFinished`][] instead.
+
+### request.writableFinished
+<!-- YAML
+added: v12.7.0
+-->
+
+* {boolean}
+
+Is `true` if all data has been flushed to the underlying system, immediately
+before the [`'finish'`][] event is emitted.
+
 ### request.write(chunk[, encoding][, callback])
 <!-- YAML
 added: v0.1.29
@@ -1436,6 +1457,17 @@ response.statusMessage = 'Not found';
 After response header was sent to the client, this property indicates the
 status message which was sent out.
 
+### response.writableEnded
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Is `true` after [`response.end()`][] has been called. This property
+does not indicate whether the data has been flushed, for this use
+[`response.writableFinished`][] instead.
+
 ### response.writableFinished
 <!-- YAML
 added: v12.7.0
@@ -2222,11 +2254,13 @@ not abort the request or do anything besides add a `'timeout'` event.
 [`request.setTimeout()`]: #http_request_settimeout_timeout_callback
 [`request.socket.getPeerCertificate()`]: tls.html#tls_tlssocket_getpeercertificate_detailed
 [`request.socket`]: #http_request_socket
+[`request.writableFinished`]: #http_request_writablefinished
 [`request.write(data, encoding)`]: #http_request_write_chunk_encoding_callback
 [`response.end()`]: #http_response_end_data_encoding_callback
 [`response.getHeader()`]: #http_response_getheader_name
 [`response.setHeader()`]: #http_response_setheader_name_value
 [`response.socket`]: #http_response_socket
+[`response.writableFinished`]: #http_response_writablefinished
 [`response.write()`]: #http_response_write_chunk_encoding_callback
 [`response.write(data, encoding)`]: #http_response_write_chunk_encoding_callback
 [`response.writeContinue()`]: #http_response_writecontinue
diff --git a/doc/api/http2.md b/doc/api/http2.md
index 1022eeb913563a..8a92aad421dea2 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -3271,6 +3271,17 @@ added: v8.4.0
 
 The [`Http2Stream`][] object backing the response.
 
+#### response.writableEnded
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Is `true` after [`response.end()`][] has been called. This property
+does not indicate whether the data has been flushed, for this use
+[`writable.writableFinished`][] instead.
+
 #### response.write(chunk[, encoding][, callback])
 <!-- YAML
 added: v8.4.0
@@ -3510,3 +3521,4 @@ following additional properties:
 [`tls.connect()`]: tls.html#tls_tls_connect_options_callback
 [`tls.createServer()`]: tls.html#tls_tls_createserver_options_secureconnectionlistener
 [error code]: #error_codes
+[`writable.writableFinished`]: stream.html#stream_writable_writablefinished
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index ef7c8c65772b9d..7199d86fd8ac2e 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -555,6 +555,10 @@ Object.defineProperty(OutgoingMessage.prototype, 'headersSent', {
   get: function() { return !!this._header; }
 });
 
+Object.defineProperty(OutgoingMessage.prototype, 'writableEnded', {
+  get: function() { return this.finished; }
+});
+
 
 const crlf_buf = Buffer.from('\r\n');
 OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {
diff --git a/lib/_stream_duplex.js b/lib/_stream_duplex.js
index 73033ab851a849..b96a0439f785fa 100644
--- a/lib/_stream_duplex.js
+++ b/lib/_stream_duplex.js
@@ -74,7 +74,7 @@ Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
   // userland will fail
   enumerable: false,
   get() {
-    return this._writableState.highWaterMark;
+    return this._writableState && this._writableState.highWaterMark;
   }
 });
 
@@ -94,7 +94,7 @@ Object.defineProperty(Duplex.prototype, 'writableLength', {
   // userland will fail
   enumerable: false,
   get() {
-    return this._writableState.length;
+    return this._writableState && this._writableState.length;
   }
 });
 
@@ -104,7 +104,7 @@ Object.defineProperty(Duplex.prototype, 'writableFinished', {
   // userland will fail
   enumerable: false,
   get() {
-    return this._writableState.finished;
+    return this._writableState ? this._writableState.finished : false;
   }
 });
 
@@ -114,7 +114,7 @@ Object.defineProperty(Duplex.prototype, 'writableEnded', {
   // userland will fail
   enumerable: false,
   get() {
-    return this._writableState.ending;
+    return this._writableState ? this._writableState.ending : false;
   }
 });
 
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
index 5236258f77f954..5ce27c067a633b 100644
--- a/lib/_stream_writable.js
+++ b/lib/_stream_writable.js
@@ -358,7 +358,7 @@ Object.defineProperty(Writable.prototype, 'writableEnded', {
   // userland will fail
   enumerable: false,
   get: function() {
-    return this._writableState.ending;
+    return this._writableState ? this._writableState.ending : false;
   }
 });
 
@@ -368,7 +368,7 @@ Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
   // userland will fail
   enumerable: false,
   get: function() {
-    return this._writableState.highWaterMark;
+    return this._writableState && this._writableState.highWaterMark;
   }
 });
 
@@ -731,7 +731,7 @@ Object.defineProperty(Writable.prototype, 'writableFinished', {
   // userland will fail
   enumerable: false,
   get() {
-    return this._writableState.finished;
+    return this._writableState ? this._writableState.finished : false;
   }
 });
 
diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index b4357058540429..9cf19250a8a3b0 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -454,6 +454,11 @@ class Http2ServerResponse extends Stream {
     return this.headersSent;
   }
 
+  get writableEnded() {
+    const state = this[kState];
+    return state.ending;
+  }
+
   get finished() {
     const stream = this[kStream];
     return stream.destroyed ||
diff --git a/test/parallel/test-http-outgoing-finish-writable.js b/test/parallel/test-http-outgoing-finish-writable.js
index e03901fb6ddf07..e3c870164bac58 100644
--- a/test/parallel/test-http-outgoing-finish-writable.js
+++ b/test/parallel/test-http-outgoing-finish-writable.js
@@ -9,12 +9,14 @@ const http = require('http');
 const server = http.createServer(common.mustCall(function(req, res) {
   assert.strictEqual(res.writable, true);
   assert.strictEqual(res.finished, false);
+  assert.strictEqual(res.writableEnded, false);
   res.end();
 
   // res.writable is set to false after it has finished sending
   // Ref: https://github.com/nodejs/node/issues/15029
   assert.strictEqual(res.writable, true);
   assert.strictEqual(res.finished, true);
+  assert.strictEqual(res.writableEnded, true);
 
   server.close();
 }));
diff --git a/test/parallel/test-http2-compat-serverresponse-end.js b/test/parallel/test-http2-compat-serverresponse-end.js
index e0a49ca23a45f1..5bbb24bb2edb31 100644
--- a/test/parallel/test-http2-compat-serverresponse-end.js
+++ b/test/parallel/test-http2-compat-serverresponse-end.js
@@ -150,8 +150,10 @@ const {
   // for http1 compatibility
   const server = createServer(mustCall((request, response) => {
     strictEqual(response.finished, true);
+    strictEqual(response.writableEnded, false);
     response.writeHead(HTTP_STATUS_OK, { foo: 'bar' });
     response.end('data', mustCall());
+    strictEqual(response.writableEnded, true);
   }));
   server.listen(0, mustCall(() => {
     const { port } = server.address();
diff --git a/test/parallel/test-http2-compat-serverresponse-finished.js b/test/parallel/test-http2-compat-serverresponse-finished.js
index 4da592a5b354b0..a42d40227ca33b 100644
--- a/test/parallel/test-http2-compat-serverresponse-finished.js
+++ b/test/parallel/test-http2-compat-serverresponse-finished.js
@@ -25,8 +25,10 @@ server.listen(0, common.mustCall(() => {
       }));
     }));
     assert.strictEqual(response.finished, false);
+    assert.strictEqual(response.writableEnded, false);
     response.end();
     assert.strictEqual(response.finished, true);
+    assert.strictEqual(response.writableEnded, true);
   }));
 
   const url = `http://localhost:${port}`;