dev-null Stream Sink

0.1.1 · active · verified Sun Apr 19

The `dev-null` package for Node.js provides a straightforward implementation of a `/dev/null` stream, consuming all piped input data without emitting any output. This utility is particularly useful in testing, debugging, or scenarios where stream data needs to be discarded to prevent side effects, such as when monitoring stream events rather than their payload. Currently at version 0.1.1, the package is exceptionally stable due to its singular, well-defined purpose, and is not expected to receive frequent updates or new features. Its key differentiator is its minimal API and focused functionality, making it a drop-in solution for stream nullification without introducing unnecessary overhead or complex configurations, serving as a direct parallel to the Unix `/dev/null` device for data streams.

Common errors

```
TypeError: devnull is not a function
```
cause Attempting to pipe directly to the imported `devnull` module (e.g., `someStream.pipe(devnull)`). The `dev-null` module exports a function that, when called, returns a new writable stream instance.

fix Call the `devnull` function to create an instance of the null stream: `someStream.pipe(devnull());`
```
SyntaxError: Cannot use import statement outside a module
```
cause Trying to use `import devnull from 'dev-null';` in a Node.js environment configured for CommonJS (e.g., no `"type": "module"` in `package.json`).

fix Change the import to a CommonJS `require` statement: `const devnull = require('dev-null');` or configure your project as an ESM module by adding `"type": "module"` to your `package.json`.

Warnings

gotcha The `dev-null` package acts as a data sink. It consumes all piped data without emitting any output itself. Expecting data to pass through or be transformed by `dev-null()` is a misunderstanding of its purpose.
Fix: Ensure you intend to discard data. If you need transformation or logging, use a `through` stream or a custom `Writable` stream.
gotcha This package is a CommonJS module. When using it in an ECMAScript Module (ESM) project, direct `import devnull from 'dev-null';` might require specific Node.js configuration (e.g., 'type: module' in package.json) or a bundler to resolve correctly, potentially leading to 'require() of ES module' errors in some setups.
Fix: For CommonJS, use `const devnull = require('dev-null');`. For ESM, consider using `import devnull from 'dev-null';` with Node.js 'type: module' project setup or use `createRequire` if mixing CJS and ESM in a complex way.
gotcha The package is at version 0.1.1 and appears to be in a very stable, low-maintenance state. While functional, it's unlikely to receive new features, active bug fixes, or updates to modern Node.js stream APIs. This is generally not an issue given its simple utility, but users should be aware of the lack of active development.
Fix: No fix needed if current functionality meets requirements. For highly active development or specific modern stream features, consider if a more actively maintained alternative exists, though few would be simpler for this task.

Install

npm install dev-null npm
yarn add dev-null yarn
pnpm add dev-null pnpm

Imports

devnull
wrong:
```
import devnull from 'dev-null';
```
correct:
```
const devnull = require('dev-null');
```
Primary CommonJS import. The package exports a function, not a stream instance directly.
devnull()
wrong:
```
someStream.pipe(devnull);
```
correct:
```
someStream.pipe(devnull());
```
You must call `devnull()` to get a new writable stream instance to pipe into.
devnull (ESM)
wrong:
```
import { devnull } from 'dev-null';
```
correct:
```
import devnull from 'dev-null'; // With transpiler or 'type: module'
```
While primarily CJS, modern Node.js ESM projects might use a default import with appropriate configuration (e.g., 'type: module' in package.json and import maps or bundlers).

Quickstart

Demonstrates piping a readable stream into dev-null to silence its output, contrasting it with a stream that outputs data.

const devnull = require('dev-null');
const { Readable } = require('stream');

// A simple readable stream that emits numbers
class NumberReadable extends Readable {
  constructor(options) {
    super(options);
    this.current = 0;
    this.to = options.to || 5;
  }

  _read() {
    if (this.current > this.to) {
      this.push(null); // No more data
      return;
    }
    this.push(Buffer.from(String(this.current++)));
  }
}

console.log('--- Piping numbers to dev-null (no output expected) ---');

new NumberReadable({ to: 5 })
  .pipe(devnull())
  .on('data', (d) => {
    // This event should ideally not fire if dev-null works correctly
    console.log('Unexpected data received:', d.toString());
  })
  .on('end', () => {
    console.log('Stream ended after piping to dev-null. This message indicates successful consumption.');
  });

console.log('\n--- Example without dev-null (output expected) ---');

new NumberReadable({ to: 2 })
  .on('data', (d) => {
    console.log('Data without dev-null:', d.toString());
  })
  .on('end', () => {
    console.log('Stream ended without dev-null. This message follows expected data output.');
  });

view raw JSON →