About

Node.js callback conventions follow the error-first pattern: the last argument is a function receiving err and result. Generator-based control flow libraries such as co expect yieldable values - thunks or Promises. Manually wrapping every callback function is tedious and error-prone. A missed error branch or a swapped argument index causes silent failures that surface only at runtime under load. This tool parses your callback-style function signatures and emits wrapped versions as thunks (single-arity functions returning function(done)) or as Promises via explicit constructor or util.promisify output. It handles arrow functions, rest parameters, and default values. The conversion is purely structural - it does not execute your code. Limitation: deeply nested or dynamically constructed callbacks cannot be detected by static pattern matching.

Formulas

A thunk is a function of arity 1 that accepts a single done callback. The conversion identity for an error-first callback function f with n arguments plus callback:

thunkify(f) = function(a₁, a₂, …, a_n) { return function(done) { f(a₁, …, a_n, done); }; }

The Promise conversion follows the constructor pattern:

promisify(f) = function(a₁, …, a_n) { return new Promise(function(resolve, reject) { f(a₁, …, a_n, function(err, res) { if (err) reject(err); else resolve(res); }); }); }

Where f is the original callback-style function, a₁ through a_n are the non-callback arguments, done is the thunk consumer callback, err follows the Node.js error-first convention, and res is the success value. The util.promisify output delegates to Node's internal implementation which additionally respects util.promisify.custom symbols.

Reference Data

Pattern	Signature	Yieldable?	Output Style	co Compatible	async/await Compatible
Error-first callback	fn(arg, cb(err, res))	No (raw)	Thunk / Promise	After wrap	After wrap
Thunk	fn(arg) → function(done)	Yes	Native	Yes	No
Promise	fn(arg) → Promise	Yes	Native	Yes	Yes
util.promisify	util.promisify(fn)	Yes	Promise	Yes	Yes
Node stream	EventEmitter-based	No	Needs wrapper lib	No	No
Synchronous	fn(arg) → value	Yes (trivially)	Already yieldable	Yes	Yes
Multi-callback	fn(onSuccess, onError)	No	Custom wrap needed	No	No
Continuation-passing	fn(arg, k)	No	Thunk-convertible	After wrap	After wrap
Bluebird promisifyAll	Bulk conversion	Yes	Promise	Yes	Yes
cb-style with context	obj.method(arg, cb)	No	Needs .bind	After bind+wrap	After bind+wrap
Nested callbacks	Callback inside callback	No	Flatten first	No	No
Event + callback hybrid	Mixed patterns	No	Manual refactor	No	No

Frequently Asked Questions

A thunk is a function that accepts a single callback argument (function(done){ ... }). Libraries like co detect thunks by checking if the yielded value is a function of arity 1. Promises expose .then() and are also detected by co. The practical difference: thunks are lighter (no microtask queue overhead) but cannot be composed with async/await. Promises integrate with the language natively since ES2017. For new code, Promises are preferred. For legacy co/koa v1 codebases, thunks remain relevant.

The converter identifies the last parameter of each function signature and checks if its name matches common callback conventions: cb, callback, done, next, fn, handler. You can also specify a custom callback parameter name. If the last parameter does not match any convention, the function is flagged as non-convertible unless you force conversion.

In the error-first convention, some functions pass multiple success values: cb(null, result1, result2). The thunk output preserves all arguments as-is since the thunk consumer receives the raw callback arguments. The Promise output resolves with the first result by default. If you enable the "multi-result" option, it resolves with an array [result1, result2, ...]. Node's util.promisify uses a custom symbol [util.promisify.custom] for such cases.

By default, the wrapper calls the original function without explicit binding, inheriting whatever this context the caller provides. If you need to preserve a specific context (e.g., an object method), enable the "Bind Context" option. This wraps the call with .call(this, ...) so the wrapper is transparent to this.

Yes. The parser recognizes arrow function syntax (const fn = (arg, cb) => { ... }), function declarations, function expressions, and module.exports assignments. It also detects exports.methodName patterns. Arrow functions that use implicit return (no braces) with a callback parameter are uncommon and likely indicate a non-callback pattern; the converter will flag these with a warning.

Thunks handle synchronous callbacks correctly since the done function is invoked immediately. Promises always resolve asynchronously due to microtask scheduling. This means code relying on synchronous callback execution order may behave differently after promisification. The converter adds a comment warning when it detects potential synchronous callback invocations.