Socket
Socket
Sign inDemoInstall

delayed-stream

Package Overview
Dependencies
0
Maintainers
0
Versions
9
Alerts
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

delayed-stream

Buffers events from a stream until you are ready to handle them.


Version published
Maintainers
0
Weekly downloads
37,750,499
decreased by-7.79%

Weekly downloads

Package description

What is delayed-stream?

The delayed-stream package is a Node.js module that allows you to buffer a stream and release it only when you decide to. This can be useful when you need to collect data from a stream before processing it, or when you want to ensure that a stream's data is only consumed after a certain event or condition is met.

What are delayed-stream's main functionalities?

Create a delayed stream

This feature allows you to create a delayed stream from an existing readable stream. The data from the original stream is buffered until you decide to release it, for example, using a timeout as shown in the code sample.

const DelayedStream = require('delayed-stream');
const fs = require('fs');

const source = fs.createReadStream('source.txt');
const delayed = DelayedStream.create(source);

// You can now wire up event listeners
source.on('data', function(data) {
  console.log('Received data: ' + data);
});

// And later, release the buffered data
setTimeout(function() {
  delayed.pipe(process.stdout);
}, 5000);

Other packages similar to delayed-stream

Readme

Source

delayed-stream

Buffers events from a stream until you are ready to handle them.

Installation

npm install delayed-stream

Usage

The following example shows how to write a http echo server that delays its response by 1000 ms.

var DelayedStream = require('delayed-stream');
var http = require('http');

http.createServer(function(req, res) {
  var delayed = DelayedStream.create(req);

  setTimeout(function() {
    res.writeHead(200);
    delayed.pipe(res);
  }, 1000);
});

If you are not using Stream#pipe, you can also manually release the buffered events by calling delayedStream.resume():

var delayed = DelayedStream.create(req);

setTimeout(function() {
  // Emit all buffered events and resume underlaying source
  delayed.resume();
}, 1000);

Implementation

In order to use this meta stream properly, here are a few things you should know about the implementation.

Event Buffering / Proxying

All events of the source stream are hijacked by overwriting the source.emit method. Until node implements a catch-all event listener, this is the only way.

However, delayed-stream still continues to emit all events it captures on the source, regardless of whether you have released the delayed stream yet or not.

Upon creation, delayed-stream captures all source events and stores them in an internal event buffer. Once delayedStream.release() is called, all buffered events are emitted on the delayedStream, and the event buffer is cleared. After that, delayed-stream merely acts as a proxy for the underlaying source.

Error handling

Error events on source are buffered / proxied just like any other events. However, delayedStream.create attaches a no-op 'error' listener to the source. This way you only have to handle errors on the delayedStream object, rather than in two places.

Buffer limits

delayed-stream provides a maxDataSize property that can be used to limit the amount of data being buffered. In order to protect you from bad source streams that don't react to source.pause(), this feature is enabled by default.

API

DelayedStream.create(source, [maxDataSize])

Returns a new delayedStream that will emit an error if the maxDataSize is exceeded.

Upon creation, the source.pause() is called.

delayedStream.source

The source stream managed by this object. This is useful if you are passing your delayedStream around, and you still want to access properties on the source object.

delayedStream.maxDataSize = 1024 * 1024

The amount of data to buffer before emitting an error.

If the underlaying source is emitting Buffer objects, the maxDataSize refers to bytes.

If the underlaying source is emitting JavaScript strings, the size refers to characters.

If you know what you are doing, you can set this property to Infinity to disable this feature.

delayedStream.dataSize = 0

The amount of data buffered so far.

delayedStream.readable

An ECMA5 getter that returns the value of source.readable.

delayedStream.resume()

If the delayedStream has not been released so far, delayedStream.release() is called.

In either case, source.resume() is called.

delayedStream.pause()

Calls source.pause().

delayedStream.pipe(dest)

Calls delayedStream.resume() and then proxies the arguments to source.pipe.

delayedStream.release()

Emits and clears all events that have been buffered up so far. This does not resume the underlaying source, use delayedStream.resume() instead.

License

delayed-stream is licensed under the MIT license.

FAQs

Last updated on 22 May 2011

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc