duplexify

What is duplexify?

The duplexify npm package allows you to turn a writable and readable stream into a single duplex stream. This can be useful when you need to present a single stream interface while having separate underlying sources for the readable and writable sides.

What are duplexify's main functionalities?

Creating a duplex stream from separate readable and writable streams

This feature allows you to combine a readable stream and a writable stream into a duplex stream, which can be both read from and written to.

const duplexify = require('duplexify');
const fs = require('fs');

const readable = fs.createReadStream('source.txt');
const writable = fs.createWriteStream('destination.txt');
const duplexStream = duplexify(writable, readable);

// Now you can read from and write to duplexStream as if it were a single stream.

Dynamically setting the readable or writable part of the duplex stream

This feature allows you to dynamically set or swap out the readable and writable components of the duplex stream after it has been created.

const duplexify = require('duplexify');
const duplexStream = duplexify();

duplexStream.setReadable(readableStream);
duplexStream.setWritable(writableStream);

Handling errors and closing the stream properly

This feature demonstrates how to handle errors and the closing of the duplex stream, ensuring that resources are cleaned up properly.

const duplexify = require('duplexify');
const duplexStream = duplexify(writable, readable);

duplexStream.on('error', (err) => {
  console.error('Stream error:', err);
});

duplexStream.on('finish', () => {
  console.log('Writable stream finished writing.');
});

duplexStream.on('end', () => {
  console.log('Readable stream finished reading.');
});

Other packages similar to duplexify

through2

Through2 is a tiny wrapper around Node streams.Transform, making it easier to create transform streams. It is similar to duplexify in that it helps with stream manipulation, but it focuses more on transforming data rather than combining separate readable and writable streams.

pumpify

Pumpify combines an array of streams into a single duplex stream using pump and duplexify under the hood. It is similar to duplexify but is specifically designed to create a pipeline of streams that can be treated as a single duplex stream.

from2

From2 is a high-level module for creating readable streams that properly handle backpressure. While it does not combine streams into a duplex stream like duplexify, it provides a simple interface for creating readable streams from functions.

stream-combiner2

Stream-combiner2 turns a pipeline of streams (readable, transform, and writable) into a single duplex stream. It is similar to duplexify but is more focused on combining streams into a pipeline rather than just pairing a readable with a writable stream.

README

duplexify

Turn a writeable and readable stream into a single streams2 duplex stream.

Similar to duplexer2 except it supports both streams2 and streams1 as input and it allows you to set the readable and writable part asynchronously using setReadable(stream) and setWritable(stream)

npm install duplexify

Usage

Use duplexify(writable, readable, streamOptions) (or duplexify.obj(writable, readable) to create an object stream)

var duplexify = require('duplexify')

// turn writableStream and readableStream into a single duplex stream
var dup = duplexify(writableStream, readableStream)

dup.write('hello world') // will write to writableStream
dup.on('data', function(data) {
  // will read from readableStream
})

You can also set the readable and writable parts asynchronously

var dup = duplexify()

dup.write('hello world') // write will buffer until the writable
                         // part has been set

// wait a bit ...
dup.setReadable(readableStream)

// maybe wait some more?
dup.setWritable(writableStream)

If you call setReadable or setWritable multiple times it will unregister the previous readable/writable stream. To disable the readable or writable part call setReadable or setWritable with null.

If the readable or writable streams emits an error or close it will destroy both streams and bubble up the event. You can also explictly destroy the streams by calling dup.destroy(). The destroy method optionally takes an error object as argument, in which case the error is emitted as part of the error event.

dup.on('error', function(err) {
  console.log('readable or writable emitted an error - close will follow')
})

dup.on('close', function() {
  console.log('the duplex stream is destroyed')
})

dup.destroy() // calls destroy on the readable and writable part (if present)

HTTP request example

Turn a node core http request into a duplex stream is as easy as

var duplexify = require('duplexify')
var http = require('http')

var request = function(opts) {
  var req = http.request(opts)
  var dup = duplexify(req)
  req.on('response', function(res) {
    dup.setReadable(res)
  })
  return dup
}

var req = request({
  method: 'GET',
  host: 'www.google.com',
  port: 80
})

req.end()
req.pipe(process.stdout)

License

MIT

Related

duplexify is part of the mississippi stream utility collection which includes more useful stream modules similar to this one.