Promisify II — JavaScript Challenge | FineFrontend

Practice workspaceSign in

JavaScript/Promisify IImedium

00:00

Read here. Code on desktop. The coding workspace opens on screens 1024px and wider.

JavaScript interview question

Promisify II

medium20 min

Extend promisify(fn) with a custom override so callback-based APIs can choose their own return value or adapt a non-standard callback signature.

Attach the override using fn[promisify.custom] = customFunction. Your implementation must prefer this function and otherwise use the error-first, callback-last behavior from Promisify.

Requirements

Export promisify as both a named and default export. Expose one stable symbol as promisify.custom; the starter supplies it.
Throw TypeError synchronously if fn is not a function.
Read fn[promisify.custom] when promisify is called. If it is a function, return that exact function without invoking, binding, or wrapping it. Its arguments, this, return values, and errors are entirely controlled by the override.
A null or undefined override means no override. Any other non-function override must throw TypeError synchronously, including false, zero, and an empty string.
Without an override, return a lazy reusable wrapper that creates a fresh Promise for each call, forwards arguments, appends an error-first callback, and preserves call-time this.
A truthy callback error rejects with that exact reason; a falsy error resolves with the second callback argument, including undefined. Ignore the original normal return value.
Support immediate and asynchronous callbacks. Synchronous exceptions reject the fallback Promise. The first settlement wins.
Do not mutate the original function or rely on a string custom property or a different symbol. Implement this yourself without importing Node util. Node-specific symbol registration and prototype copying are out of scope.

Examples

Example 1

Input: const add = (a, b, callback) => callback(null, a + b);
await promisify(add)(2, 3);
Output: 5

Example 2

Input: const task = (callback) => callback(null, "original");
const custom = () => Promise.resolve("custom");
task[promisify.custom] = custom;

promisify(task) === custom;
await promisify(task)();
Output: true
"custom"

Example 3

Input: const task = () => {};
task[promisify.custom] = () => 42;
promisify(task)();
Output: 42 (returned directly, without an extra Promise)

The custom override is returned unchanged. Only the fallback adapts callbacks to promises.

What the tests check

Returns a lazy wrapper and a Promise for synchronous callbacks
Forwards all arguments and appends the callback
Resolves asynchronously without using the original return value
Preserves call-time this for object methods
Rejects with the original callback error
Rejects asynchronous callback errors and non-Error reasons
Turns synchronous exceptions into rejections
Resolves falsy results and missing success values
Treats falsy error arguments as success
Uses the first callback settlement
Ignores a throw after an already settled callback
Keeps concurrent calls and Promise instances independent
Exposes a stable symbol shared by both exports
Returns the override by identity without executing either function
Allows custom arguments and multiple success values
Preserves custom call context and exact return values
Does not wrap custom synchronous errors or rejected promises
Rejects non-function overrides including falsy values
Uses callback fallback for null or undefined overrides
Ignores unrelated symbols and string custom properties
Reads the override at adaptation time without mutating the original
Rejects non-function inputs synchronously

References

Promise constructor Function.prototype.call()Node.js custom promisified functions

Related challenges

Promisify

PromisesCallbacksAsync JavaScriptFunction ContextSymbols

Back

Preparing your workspace…