stream-demux 8.0.0 → 9.0.0

package/README.md

@@ -43,7 +43,7 @@ let demux = new StreamDemux();
   // the same time.
   // Note that you can optionally pass a number n to the
   // createConsumer(n) method to force the iteration to
-  // timeout after n milliseconds of innactivity.
+  // timeout after n milliseconds of inactivity.
   let consumer = demux.stream('def').createConsumer();
   while (true) {
     let packet = await consumer.next();

package/index.js

@@ -112,6 +112,14 @@ class StreamDemux {
     return this._mainStream.hasConsumer(consumerId);
   }
 
+  getConsumerCount(streamName) {
+    return this.getConsumerStatsList(streamName).length;
+  }
+
+  getConsumerCountAll() {
+    return this.getConsumerStatsListAll().length;
+  }
+
   createConsumer(streamName, timeout) {
     let mainStreamConsumer = this._mainStream.createConsumer(timeout);
 
@@ -136,6 +144,16 @@ class StreamDemux {
       }
     };
 
+    let consumerClearActiveTimeout = mainStreamConsumer.clearActiveTimeout;
+    mainStreamConsumer.clearActiveTimeout = function (packet) {
+      let { value, done } = packet;
+      if (done) {
+        consumerClearActiveTimeout.apply(this, arguments);
+      } else if (value && value.stream === streamName) {
+        consumerClearActiveTimeout.apply(this, arguments);
+      }
+    };
+
     let consumerGetStats = mainStreamConsumer.getStats;
     mainStreamConsumer.getStats = function () {
       let stats = consumerGetStats.apply(this, arguments);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stream-demux",
-  "version": "8.0.0",
+  "version": "9.0.0",
   "description": "A consumable stream demultiplexer.",
   "main": "index.js",
   "scripts": {
@@ -28,7 +28,7 @@
     "mocha": "^5.0.5"
   },
   "dependencies": {
-    "consumable-stream": "^2.0.0",
-    "writable-consumable-stream": "^2.0.0"
+    "consumable-stream": "^3.0.0",
+    "writable-consumable-stream": "^4.0.0"
   }
 }

package/test/test.js

@@ -296,6 +296,74 @@ describe('StreamDemux', () => {
     assert.equal(packet, null);
   });
 
+  it('should prevent stream.once() timeout from being reset when writing to other streams', async () => {
+    (async () => {
+      for (let i = 0; i < 15; i++) {
+        await wait(20);
+        demux.write('hi', 'test');
+      }
+    })();
+
+    let substream = demux.stream('hello');
+
+    let packet;
+    let error;
+    try {
+      packet = await substream.once(200);
+    } catch (err) {
+      error = err;
+    }
+
+    assert.notEqual(error, null);
+    assert.equal(error.name, 'TimeoutError');
+    assert.equal(packet, null);
+  });
+
+  it('should prevent stream.once() timeout from being reset when killing other streams', async () => {
+    (async () => {
+      for (let i = 0; i < 15; i++) {
+        await wait(20);
+        demux.kill('hi' + i, 'test');
+      }
+    })();
+
+    let substream = demux.stream('hello');
+
+    let packet;
+    let error;
+    try {
+      packet = await substream.once(200);
+    } catch (err) {
+      error = err;
+    }
+
+    assert.notEqual(error, null);
+    assert.equal(error.name, 'TimeoutError');
+    assert.equal(packet, null);
+  });
+
+  it('should support stream.once() timeout after killing the stream', async () => {
+    (async () => {
+      await wait(20);
+      demux.kill('hello', 'test');
+    })();
+
+    let substream = demux.stream('hello');
+
+    let start = Date.now();
+
+    let packet;
+    let error;
+    try {
+      packet = await substream.once(200);
+    } catch (err) {
+      error = err;
+    }
+    assert.notEqual(error, null);
+    assert.equal(error.name, 'TimeoutError');
+    assert.equal(packet, null);
+  });
+
   it('should support stream.next() method with close command', async () => {
     (async () => {
       for (let i = 0; i < 3; i++) {