Which Node.js Core Utilities Should You Upgrade? A Hands‑On Comparison

Origin

In 2021 Node.js LTS reached 16.x, and the ecosystem grew to over 1.7 million npm packages, leading to many layered wrappers. The author, a maintainer of Egg.js, revisits several foundational libraries to see which can be retired in favor of newer, built‑in solutions.

New vs Old

Type Checking

Scenario: JavaScript type checking is often criticized. The community package is-type-of covers most cases, while Node.js provides util.types since 10.x.

const is = require('is-type-of');
is.regexp(/.*/);
is.asyncFunction(async function foo() {});
is.string(str);

VS

const types = require('util/types'); // 10.x use require('util').types
types.isRegExp(/.*/);
types.isAsyncFunction(async function foo() {});
typeof str === 'string';

Replacement rating: ★★★★☆ (easy to replace).

setTimeout / Sleep

Scenario: Waiting for a period, similar to sleep in other languages.

const { sleep } = require('mz-modules');
await sleep('1s');

VS

const { setTimeout } = require('timers/promises');
await setTimeout(1000);
// Older versions require manual promisify
await new Promise(resolve => setTimeout(resolve, 1000));

Replacement rating: ★★★★★ (highly recommended).

File Handling

Scenario: Common file operations like existence checks, reading, writing, and directory manipulation.

// Using mz (Promise‑based API)
const { fs } = require('mz');
await fs.exists('/path/to/file');
await fs.readFile('/path/to/file');
await fs.writeFile('/path/to/file', 'some text');

// Using mz-modules for mkdirp and rimraf
const { mkdirp, rimraf } = require('mz-modules');
await rimraf('/path/to/dir'); // Recursive delete (hard on Windows before)
await mkdirp('/path/to/dir'); // mkdir -p equivalent

VS

const fsPromise = require('fs/promises');
await fsPromise.access('/path/to/file').then(() => true, () => false);
await fsPromise.readFile('/path/to/file');
await fsPromise.writeFile('/path/to/file', 'some text');
await fsPromise.rm('/path/to/dir', { force: true, recursive: true, maxRetries: 5 });
await fsPromise.mkdir('/path/to/dir', { recursive: true });

Replacement rating: ★★★★★ (use built‑in promises).

Stream Processing

Scenario: Pipe a zip file through zlib and write the result, handling errors at each stage.

await new Promise((resolve, reject) => {
  fs.createReadStream('/path/to/src.zip')
    .pipe(zlib.createGunzip())
    .pipe(fs.createWriteStream('/path/to/target.js'))
    .on('error', reject)
    .on('finish', resolve);
});

VS (using pump or stream/pipeline)

const { pump } = require('mz-modules');
await pump(
  fs.createReadStream('/path/to/src.zip'),
  zlib.createGunzip(),
  fs.createWriteStream('/path/to/target.js')
);

const { pipeline } = require('stream/promises');
await pipeline(
  fs.createReadStream('/path/to/src.zip'),
  zlib.createGunzip(),
  fs.createWriteStream('/path/to/target.js')
);

Replacement rating: ★★★★★ (prefer built‑in pipeline).

HTTP Requests

Scenario: Making core HTTP calls; the legacy http module is low‑level.

const httpclient = require('urllib');
const result = await httpclient.request(url, {
  method: 'post',
  contentType: 'json',
  dataType: 'json',
  data: { hello: 'world', now: Date.now() }
});
console.log(result.status);
console.log(result.headers);
console.log(result.data);

VS

const { request } = require('undici');
const result = await request(url, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ hello: 'world', now: Date.now() })
});
console.log(result.statusCode);
console.log(result.headers);
console.log(await result.body.json());

Replacement rating: ★★★☆☆ (undici promising but still maturing).

Assertions

Scenario: Assertion libraries for testing.

Community options: power-assert, chai. Node.js provides assert/strict and CallTracker since 10.x.

Replacement rating: ★★☆☆☆ (keep an eye on strict mode).

Code Coverage

Scenario: Measuring test coverage.

Community tool: nyc (requires transpilation). Built‑in V8 coverage via c8 (Node 16+).

$ nyc mocha
$ open coverage/lcov-report/index.html

VS

$ c8 mocha
$ open coverage/index.html

Replacement rating: ★★★★☆ (prefer V8 native coverage).

Debug Logging

Scenario: Conditional debug output.

// Using debug package
const debug = require('debug')('egg-bin:test');
debug('launch application at %s', host);
// Activate via DEBUG env var
$ DEBUG=egg-core,egg-bin:* node index.js

VS

// Using Node's util.debuglog
const util = require('util');
const debug = util.debuglog('egg-bin:test');
debug('launch application at %s', host);
// Activate via NODE_DEBUG env var
$ NODE_DEBUG=egg-core,egg-bin:* node index.js

Replacement rating: ★★★★☆ (debug package mirrors util.debuglog).

Deprecated APIs

Scenario: Wrapping old APIs with warnings.

const deprecate = require('deprecate');
const fn = (...args) => {
  deprecate('`app.get` is deprecated, please use `app.router.get` instead.');
  return originFn(...args);
};

VS

const util = require('util');
const fn = util.deprecate(originFn, '`app.get` is deprecated, please use `app.router.get` instead.', 'DEP0001');

Replacement rating: ★★★★★ (use built‑in util.deprecate).

Source Maps

Scenario: Mapping stack traces back to original TypeScript sources.

// Compile with inline source map
$ tsc --inlineSourceMap test.ts
$ node test.js   // Shows compiled line numbers

// Use source‑map‑support
$ node -r source-map-support/register test.js

// Node built‑in flag
$ node --enable-source-maps test.js

Replacement rating: ★★★★★ (Node's native support).

Child Processes

Scenario: Forking subprocesses.

// Using runscript
const runscript = require('runscript');
const { stdout, stderr } = await runscript('node index.js', { stdio: 'pipe' });
console.log(stdout);
console.error(stderr);

VS

// Using execa
const execa = require('execa');
const proc = execa.node('index.js', opts);
const { stdout, stderr, exitCode } = await proc;
console.log(stdout);
console.error(stderr);

Replacement rating: ★★★★★ (both wrap child_process, execa offers more features).

CLI Testing

Scenario: Testing command‑line tools.

// Using coffee (Egg's CLI test framework)
const coffee = require('coffee');
describe('cli', () => {
  it('should fork node cli', async () => {
    return coffee.fork('/path/to/file.js')
      .expect('stdout', '12
')
      .expect('stderr', /34/)
      .expect('code', 0)
      .end();
  });
});

VS

// Using clet (newer framework)
import { runner, KEYS } from 'clet';
await runner()
  .cwd(tmpDir, { init: true })
  .spawn('npm init')
  .stdin(/name:/, 'example')
  .stdin(/version:/, new Array(9).fill(KEYS.ENTER))
  .stdout(/"name": "example"/)
  .notStderr(/npm ERR/)
  .file('package.json', { name: 'example', version: '1.0.0' });

Replacement rating: ★★★★☆ (clet adds modern features).

Conclusion

The author reflects that many of their own libraries (mz, mz-modules, etc.) can now be retired thanks to Node.js’s evolving built‑in APIs. They encourage developers to adopt the newer native capabilities, contribute to Node.js discussions, and avoid maintaining outdated wrappers for long‑term LTS versions.