Convert Callback Based Function to Promise Based Function

Convert Callback Based Function to Promise Based Function - Problem

JavaScript Medium

In the evolution of JavaScript asynchronous programming, we've moved from callback-based functions to Promise-based functions for better error handling and code readability. Your task is to create a promisify function that bridges this gap.

The Challenge: Write a function that accepts a callback-based function fn and converts it into a promise-based function. The original function fn follows the Node.js callback convention where:

The first parameter is always a callback function
The callback receives (result, error) as parameters
If there's an error, it's passed as the second argument
If successful, the result is passed as the first argument

Your promisify function should:

Return a new function that returns a Promise
Resolve with the result when the callback is called without an error
Reject with the error when the callback is called with an error

Example transformation:

// Original callback-based function
function sum(callback, a, b) {
  if (a < 0 || b < 0) {
    callback(undefined, Error('a and b must be positive'));
  } else {
    callback(a + b);
  }
}

// After promisify
const promisedSum = promisify(sum);
promisedSum(3, 4).then(result => console.log(result)); // 7
promisedSum(-1, 4).catch(err => console.log(err.message)); // 'a and b must be positive'

Input & Output

example_1.js — Basic Sum Function

$ Input: fn = function sum(callback, a, b) { if (a < 0 || b < 0) { callback(undefined, new Error('a and b must be positive')); } else { callback(a + b); } } args = [3, 4]

› Output: Promise resolves to 7

💡 Note: The sum function with positive numbers resolves successfully with the result 7

example_2.js — Error Case

$ Input: fn = function sum(callback, a, b) { if (a < 0 || b < 0) { callback(undefined, new Error('a and b must be positive')); } else { callback(a + b); } } args = [-1, 4]

› Output: Promise rejects with Error('a and b must be positive')

💡 Note: When a negative number is provided, the function calls the callback with an error, causing the Promise to reject

example_3.js — Async File Operation

$ Input: fn = function readFile(callback, filename) { setTimeout(() => { if (filename === 'test.txt') { callback('file contents'); } else { callback(undefined, new Error('File not found')); } }, 100); } args = ['test.txt']

› Output: Promise resolves to 'file contents'

💡 Note: The promisified function handles asynchronous operations correctly, resolving with the file contents after the timeout

Constraints

The original function fn always takes callback as the first parameter
Callback follows Node.js convention: callback(result, error)
If error exists, result should be undefined
Your promisify function should handle any number of additional arguments
The returned function must return a proper Promise object

Visualization

Tap to expand

Understanding the Visualization

Receive Original Function

Accept the callback-based function that needs to be converted

Create Wrapper Function

Return a new function that accepts the same arguments as the original

Promise Constructor

Inside wrapper, create Promise with resolve/reject handlers

Custom Callback

Create callback that resolves/rejects Promise based on error parameter

Call Original Function

Execute original function with our custom callback and user arguments

Key Takeaway

🎯 Key Insight: The promisify pattern uses closure to capture the original function and creates a bridge between callback and Promise paradigms, making legacy code compatible with modern async/await syntax.

Asked in

N Node.js 45 G Google 35 ⊞ Microsoft 28 a Amazon 22

The optimal solution creates a wrapper function that returns a Promise. Inside the Promise constructor, we create a custom callback function that resolves or rejects the Promise based on the error parameter. This elegantly converts any Node.js-style callback function into a modern Promise-based function.

Common Approaches

Approach	Time	Space	Notes
✓ Basic Promise Wrapper	O(1)	O(1)	Simple wrapper that creates a Promise around the callback function

Basic Promise Wrapper — Algorithm Steps

Create a function that takes the callback-based function as parameter
Return a new function that accepts the original arguments
Inside the new function, return a Promise
In the Promise executor, call the original function with a custom callback
Resolve or reject the Promise based on callback parameters

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Function Call

Callback-based function is called with custom callback

Callback Execution

Original function executes and calls the callback

Promise Resolution

Custom callback resolves or rejects the Promise

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// C doesn't have native Promise support
// This is a basic structure to simulate promise-like behavior

typedef struct {
    void* result;
    char* error;
    int resolved;
    pthread_mutex_t mutex;
    pthread_cond_t condition;
} Promise;

typedef void (*Callback)(void* result, char* error);
typedef void (*AsyncFunction)(Callback callback, void** args);

Promise* create_promise() {
    Promise* p = malloc(sizeof(Promise));
    p->result = NULL;
    p->error = NULL;
    p->resolved = 0;
    pthread_mutex_init(&p->mutex, NULL);
    pthread_cond_init(&p->condition, NULL);
    return p;
}

void resolve_promise(Promise* p, void* result) {
    pthread_mutex_lock(&p->mutex);
    p->result = result;
    p->resolved = 1;
    pthread_cond_signal(&p->condition);
    pthread_mutex_unlock(&p->mutex);
}

void reject_promise(Promise* p, char* error) {
    pthread_mutex_lock(&p->mutex);
    p->error = error;
    p->resolved = 1;
    pthread_cond_signal(&p->condition);
    pthread_mutex_unlock(&p->mutex);
}

// Basic promisify concept (simplified)
Promise* promisify_call(AsyncFunction fn, void** args) {
    Promise* promise = create_promise();
    
    Callback callback = ^(void* result, char* error) {
        if (error) {
            reject_promise(promise, error);
        } else {
            resolve_promise(promise, result);
        }
    };
    
    fn(callback, args);
    return promise;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time to create the wrapper function and Promise

✓ Linear Growth

Space Complexity

O(1)

Only stores function references and arguments, no additional data structures

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic Promise Wrapper — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler