promisification

Promisification is the process of converting asynchronous APIs that rely on callbacks into interfaces that return promises. This pattern is common in JavaScript, where many legacy APIs use a callback style and Node.js often uses an error-first callback of the form function (...args, callback), with callback(err, result). A promisified function wraps the original and returns a promise that resolves with the result or rejects with the error. For example: function original(a, b, cb) { ... } const promisified = (...args) => new Promise((resolve, reject) => original(...args, (err, res) => err ? reject(err) : resolve(res)));

If the callback passes multiple results, the promise may resolve with an array or object.

Common tools include manual wrapping, Node.js util.promisify, libraries like Bluebird.promisify, or promisifyAll to convert all methods in an object. The goal is to provide a consistent, promise-based interface that can be used with then/catch or async/await.

Benefits include easier composition with async/await and more consistent error handling, while improving readability. Limitations include that not all callbacks map cleanly to a single result, callbacks that do not use the error-first pattern, event emitters, or functions that yield multiple completion events may require custom handling. Promisification does not automatically provide cancellation; some APIs require manual patterns to cancel ongoing work.

History: Promises were standardized in ECMAScript 2015, and promisification gained popularity as asynchronous code grew; Node added util.promisify to simplify conversion. Today, promisified interfaces are common in modern JavaScript, enabling use with async/await and easier testing.