Sign Up for Free

RunKit +

Try any Node.js package right in your browser

This is a playground to test code. It runs a full Node.js environment and already has all of npm’s 400,000 packages pre-installed, including @justinbeckwith/duplexify with all npm packages installed. Try it out:

var duplexify = require("@justinbeckwith/duplexify")

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

@justinbeckwith/duplexify v4.0.0

Turn a writable and readable stream into a streams2 duplex stream with support for async initialization and streams1/streams2 input

@justinbeckwith/duplexify

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

npm version Build Status codecov semantic-release Code Style: Google

Compare to duplexify

This is a fork of duplexify. It does a few things different:

  • Doesn't take a dependency on the user space ReadableStream npm module (this is smaller)
  • Uses TypeScript for type safety

Installation

npm install @justinbeckwith/duplexify

Usage

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

const {duplexify} = require('@justinbeckwith/duplexify')

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

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

You can also set the readable and writable parts asynchronously

const 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 explicitly 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', (err) => {
  console.log('readable or writable emitted an error - close will follow')
})

dup.on('close', () => {
  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

const {duplexify} = require('duplexify')
const http = require('http')

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

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

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

License

MIT

RunKit is a free, in-browser JavaScript dev environment for prototyping Node.js code, with every npm package installed. Sign up to share your code.
Sign Up for Free