Replacements for mississippi

mississippi exposes stream helpers as miss.pipe, miss.each, miss.pipeline, and so on. Each export wraps a separate npm package internally, but migration targets the miss.* call sites and replaces each with the corresponding native node:stream API below.

miss.pipe

import miss from 'mississippi'
import { pipeline } from 'node:stream/promises'

miss.pipe(s1, s2, s3, cb) 
await pipeline(s1, s2, s3) 

For callback-style usage, use stream.pipeline.

miss.each

import miss from 'mississippi'
 
miss.each(stream, (data, cb) => { 
  fn(data) 
  cb() 
}) 
 
for await (const data of stream) { 
  fn(data) 
} 

Note that miss.each reports stream errors through its done callback, while for await throws them wrap the loop in try/catch to handle errors.

miss.pipeline

import miss from 'mississippi'
import { compose } from 'node:stream'

miss.pipeline(s1, s2, s3) 
compose(s1, s2, s3) 

Requires Node.js ≥ 16.9.0.

miss.duplex

See also duplexer replacements.

import miss from 'mississippi'
import { Duplex } from 'node:stream'
 
miss.duplex(writableStream, readableStream) 
Duplex.from({ 
  writable: writableStream, 
  readable: readableStream 
}) 

Requires Node.js ≥ 16.8.0 for Duplex.from.

miss.through

See also through replacements.

import miss from 'mississippi'
import { Transform } from 'node:stream'
 
miss.through((chunk, enc, cb) => { 
  cb(null, fn(chunk)) 
}) 
new Transform({ 
  transform(chunk, encoding, callback) { 
    callback(null, fn(chunk)) 
  } 
}) 

miss.concat

See also get-stream replacements.

import miss from 'mississippi'
import { buffer } from 'node:stream/consumers'

stream.pipe(miss.concat((data) => fn(data))) 
const data = await buffer(stream) 
fn(data) 

Unlike miss.concat, which adapts its output to the input type, buffer always returns a Buffer. node:stream/consumers also exports text, json, and arrayBuffer for those cases.

Requires Node.js ≥ 16.7.0 for node:stream/consumers.

miss.finished

import miss from 'mississippi'
import { finished } from 'node:stream/promises'

miss.finished(stream, cb) 
await finished(stream) 

For callback-style usage, use stream.finished.

miss.from

import miss from 'mississippi'
import { Readable } from 'node:stream'
 
miss.from((size, cb) => cb(null, chunk)) 
Readable.from( 
  (async function* () { 
    yield chunk 
  })() 
) 

miss.to

import miss from 'mississippi'
import { Writable } from 'node:stream'
 
miss.to( 
  (chunk, enc, cb) => cb(), 
  (cb) => cb() 
) 
new Writable({ 
  write(chunk, encoding, callback) { 
    callback() 
  }, 
  final(callback) { 
    callback() 
  } 
}) 

miss.parallel

import miss from 'mississippi'
 
stream.pipe( 
  miss.parallel(10, (data, cb) => cb(null, fn(data))) 
) 
stream.map((data) => fn(data), { concurrency: 10 }) 

Like miss.parallel, map preserves the order of the input stream.

Requires Node.js >= 17.4.0 for Readable.prototype.map.