stream: add readableDidRead if has been read from

Adds did read accessor used to determine whether a readable has been
read from.

PR-URL: #39589
Refs: nodejs/undici#907
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

Author: ronag

doc/api/stream.md

@@ -1259,6 +1259,17 @@ added: v11.4.0
 Is `true` if it is safe to call [`readable.read()`][stream-read], which means
 the stream has not been destroyed or emitted `'error'` or `'end'`.
 
+##### `readable.readableDidRead`
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Allows determining if the stream has been or is about to be read.
+Returns true if `'data'`, `'end'`, `'error'` or `'close'` has been
+emitted.
+
 ##### `readable.readableEncoding`
 <!-- YAML
 added: v12.7.0

lib/internal/streams/readable.js

@@ -167,6 +167,8 @@ function ReadableState(options, stream, isDuplex) {
   // If true, a maybeReadMore has been scheduled.
   this.readingMore = false;
 
+  this.dataEmitted = false;
+
   this.decoder = null;
   this.encoding = null;
   if (options && options.encoding) {
@@ -309,6 +311,7 @@ function addChunk(stream, state, chunk, addToFront) {
     } else {
       state.awaitDrainWriters = null;
     }
+    state.dataEmitted = true;
     stream.emit('data', chunk);
   } else {
     // Update the buffer info.
@@ -519,8 +522,10 @@ Readable.prototype.read = function(n) {
       endReadable(this);
   }
 
-  if (ret !== null)
+  if (ret !== null) {
+    state.dataEmitted = true;
     this.emit('data', ret);
+  }
 
   return ret;
 };
@@ -1183,6 +1188,18 @@ ObjectDefineProperties(Readable.prototype, {
     }
   },
 
+  readableDidRead: {
+    enumerable: false,
+    get: function() {
+      return (
+        this._readableState.dataEmitted ||
+        this._readableState.endEmitted ||
+        this._readableState.errorEmitted ||
+        this._readableState.closeEmitted
+      );
+    }
+  },
+
   readableHighWaterMark: {
     enumerable: false,
     get: function() {

test/parallel/test-stream-readable-didRead.js

@@ -0,0 +1,104 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const Readable = require('stream').Readable;
+
+function noop() {}
+
+function check(readable, data, fn) {
+  assert.strictEqual(readable.readableDidRead, false);
+  if (data === -1) {
+    readable.on('error', common.mustCall());
+    readable.on('data', common.mustNotCall());
+    readable.on('end', common.mustNotCall());
+  } else {
+    readable.on('error', common.mustNotCall());
+    if (data === -2) {
+      readable.on('end', common.mustNotCall());
+    } else {
+      readable.on('end', common.mustCall());
+    }
+    if (data > 0) {
+      readable.on('data', common.mustCallAtLeast(data));
+    } else {
+      readable.on('data', common.mustNotCall());
+    }
+  }
+  readable.on('close', common.mustCall());
+  fn();
+  setImmediate(() => {
+    assert.strictEqual(readable.readableDidRead, true);
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, 0, () => {
+    readable.read();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, 0, () => {
+    readable.resume();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+  check(readable, -2, () => {
+    readable.destroy();
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push(null);
+    }
+  });
+
+  check(readable, -1, () => {
+    readable.destroy(new Error());
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push('data');
+      this.push(null);
+    }
+  });
+
+  check(readable, 1, () => {
+    readable.on('data', noop);
+  });
+}
+
+{
+  const readable = new Readable({
+    read() {
+      this.push('data');
+      this.push(null);
+    }
+  });
+
+  check(readable, 1, () => {
+    readable.on('data', noop);
+    readable.off('data', noop);
+  });
+}