or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

child-process.mdcrypto.mddns.mdfs.mdindex.mdreadline.mdzlib.md
tile.json

tessl/npm-mz

Promise-based wrappers for Node.js core APIs that modernize callback-based methods to work with async/await patterns

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/mz@2.7.x

To install, run

npx @tessl/cli install tessl/npm-mz@2.7.0

index.mddocs/

MZ - Modernize Node.js

MZ is a Node.js library that modernizes Node.js core APIs to current ECMAScript standards by providing promise-based wrappers for callback-based methods. It enables clean async/await syntax with Node.js core APIs without requiring Node.js API updates, making it ideal for applications wanting to modernize their asynchronous code patterns while maintaining compatibility with existing Node.js ecosystem tools.

Package Information

  • Package Name: mz
  • Package Type: npm
  • Language: JavaScript
  • Installation: npm install mz

Core Imports

Individual module imports (recommended):

const fs = require('mz/fs');
const crypto = require('mz/crypto');
const dns = require('mz/dns');
const zlib = require('mz/zlib');
const readline = require('mz/readline');
const child_process = require('mz/child_process');

Full library import:

const mz = require('mz');
const fs = mz.fs;
const crypto = mz.crypto;
// etc...

Basic Usage

const fs = require('mz/fs');
const crypto = require('mz/crypto');

async function example() {
  // Check if file exists
  if (await fs.exists('./package.json')) {
    // Read file contents
    const content = await fs.readFile('./package.json', 'utf8');
    console.log('Package.json content:', content);
  }
  
  // Generate random bytes
  const randomData = await crypto.randomBytes(16);
  console.log('Random bytes:', randomData.toString('hex'));
}

Architecture

MZ uses several key libraries and patterns:

  • Promise Engine: Uses any-promise for flexible promise implementation compatibility
  • Thenification: Uses thenify-all to convert callback-based methods to promise-based
  • Dual Interface: All async methods support both promises and callbacks
  • Graceful Enhancement: Uses graceful-fs when available, falls back to native fs
  • Native Compatibility: Non-async and deprecated properties are proxied unchanged

Capabilities

File System Operations

Comprehensive promise-based file system operations with graceful-fs integration and custom exists() implementation.

// Core file operations
function readFile(path, options): Promise<Buffer | string>;
function writeFile(file, data, options): Promise<void>;
function stat(path, options): Promise<Stats>;
function exists(path): Promise<boolean>;

// Directory operations
function mkdir(path, options): Promise<void>;
function readdir(path, options): Promise<string[] | Dirent[]>;
function rmdir(path, options): Promise<void>;

File System Operations

Child Process Operations

Execute shell commands and spawn processes with promise support.

function exec(command, options): Promise<string>;
function execFile(file, args, options): Promise<string>;

Child Process Operations

Cryptographic Operations

Generate random data and perform key derivation with promise support.

function randomBytes(size): Promise<Buffer>;
function pbkdf2(password, salt, iterations, keylen, digest): Promise<Buffer>;
function pseudoRandomBytes(size): Promise<Buffer>;

Cryptographic Operations

DNS Operations

Perform DNS lookups and resolve various record types with promise support.

function lookup(hostname, options): Promise<LookupResult>;
function resolve(hostname, rrtype): Promise<string[] | object[]>;
function resolve4(hostname, options): Promise<string[]>;
function resolve6(hostname, options): Promise<string[]>;

DNS Operations

Interactive Readline

Create interactive command-line interfaces with promise-based question handling and completer support.

function createInterface(options): Interface;

class Interface {
  question(query): Promise<string>;
}

Interactive Readline

Compression Operations

Compress and decompress data using various algorithms with promise support.

function gzip(buffer, options): Promise<Buffer>;
function gunzip(buffer, options): Promise<Buffer>;
function deflate(buffer, options): Promise<Buffer>;
function inflate(buffer, options): Promise<Buffer>;

Compression Operations

Types

// Common callback signature for dual interface support
type CallbackFunction<T> = (err: Error | null, result?: T) => void;

// All async functions support both interfaces:
// - Promise: functionName(args): Promise<T>
// - Callback: functionName(args, callback: CallbackFunction<T>): void