# duplexify

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

Latest version **4.1.3** (published 2024-03-06) · MIT license · 0 weekly downloads

## Install

```sh
npm install duplexify
pnpm add duplexify
yarn add duplexify
bun add duplexify
```

## Health

**Score 23/100 (F)** — status: abandoned.

Positive: has types package; no vulnerabilities; high quality score.

Warnings: low downloads; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 4.1.3 |
| Published | 2024-03-06 |
| First published | 2014-07-07 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | separate (@types/duplexify) |
| Module format | CommonJS |
| Dependencies | 4 |
| Unpacked size | 17.9 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 191 |
| Author | Mathias Buus |
| Maintainers | mafintosh |
| Keywords | duplex, streams2, streams, stream, writable, readable, async |

## Links

- npm: https://www.npmjs.com/package/duplexify
- Repository: https://github.com/mafintosh/duplexify
- Issues: https://github.com/mafintosh/duplexify/issues
- npm.io page: https://npm.io/package/duplexify

## Dependencies (4)

- [inherits](https://npm.io/package/inherits.md) ^2.0.3
- [stream-shift](https://npm.io/package/stream-shift.md) ^1.0.2
- [end-of-stream](https://npm.io/package/end-of-stream.md) ^1.4.1
- [readable-stream](https://npm.io/package/readable-stream.md) ^3.1.1

## Alternatives

- [byte-size](https://npm.io/package/byte-size.md) — 2.1M weekly downloads
- [speed-limiter](https://npm.io/package/speed-limiter.md) — 16.0K weekly downloads
- [@powersync/node](https://npm.io/package/@powersync/node.md) — 10.9K weekly downloads
- [@ledgerhq/coin-cardano](https://npm.io/package/@ledgerhq/coin-cardano.md) — 1.0K weekly downloads
- [@jayesol/jayeson.lib.streamfinder](https://npm.io/package/@jayesol/jayeson.lib.streamfinder.md) — 1.0K weekly downloads

## Recent versions

- 4.1.3 (latest) — 2024-03-06
- 4.1.2 — 2021-07-21
- 4.1.1 — 2019-06-12
- 4.1.0 — 2019-06-11
- 4.0.0 — 2019-02-04
- 3.7.1 — 2019-02-04
- 3.7.0 — 2019-02-04
- 3.6.1 — 2018-10-13
- 3.6.0 — 2018-05-04
- 3.5.4 — 2018-03-02
- 3.5.3 — 2018-01-10
- 3.5.2 — 2018-01-10
- 3.5.1 — 2017-08-01
- 3.5.0 — 2016-10-24
- 3.4.6 — 2016-10-18
- … 25 more at https://npm.io/package/duplexify/versions

## README

# duplexify

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

Similar to [duplexer2](https://github.com/deoxxa/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
```

[![build status](http://img.shields.io/travis/mafintosh/duplexify.svg?style=flat)](http://travis-ci.org/mafintosh/duplexify)

## Usage

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

``` js
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

``` js
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 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.

``` js
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

``` js
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](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.

---
_Source: https://npm.io/package/duplexify · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._