How to Override Functions of Module in Node.js ?

Overriding functions in a Node.js module allows you to alter or extend the behaviour of existing functions without modifying the original module's code. This approach can be useful for customizing library functionality, adding new features, or fixing bugs in third-party modules. Here’s how you can achieve this in different scenarios.

Using Function Replacement

One of the simplest ways to override a function is by directly replacing it with a new implementation. This method works well for both built-in and custom modules.

Example: Overriding a Custom Module Function

// math.js
module.exports = {
    add: (a, b) => a + b,
    subtract: (a, b) => a - b
};

To override the add function:

// app.js
const math = require('./math');

// Save the original function
const originalAdd = math.add;

// Override the add function
math.add = (a, b) => {
    console.log(`Adding ${a} and ${b}`);
    return originalAdd(a, b);
};

console.log(math.add(2, 3));  // Output: Adding 2 and 3 \n 5

Note: In this example, the original add function is preserved, allowing you to call it within the overridden version.

Using Proxies

Proxies in JavaScript provide a powerful way to override and extend object behavior, including functions. You can use proxies to intercept and customize method calls dynamically.

Example: Using a Proxy to Override Module Functions

// math.js
module.exports = {
    add: (a, b) => a + b,
    subtract: (a, b) => a - b
};

To override the add function:

// app.js
const math = require('./math');

const mathProxy = new Proxy(math, {
    get(target, prop) {
        if (prop === 'add') {
            return (a, b) => {
                console.log(`Custom add: ${a} + ${b}`);
                return target[prop](a, b);
            };
        }
        return target[prop];
    }
});

console.log(mathProxy.add(2, 3));  // Output: Custom add: 2 + 3 \n 5
console.log(mathProxy.subtract(5, 2));  // Output: 3

Note: The proxy intercepts calls to the add function, allowing custom behavior while still delegating to the original function.

Example: Consider a module math.js with a function add.

Installation Steps

Step 1: Now, initialize a new Node.js project with default configurations using the following command on the command line.

npm init -y

Step 2: First of all, require the module which we want to override.

const url = require('url')

Step 3: Then delete the function of the module which we want to override. Here we would override the format() function of 'url' module

delete url['format']

Step 4: Now add the function with the same name 'format' to provide a new definition to the format() function of the module

url.format = function(params...) {
    // statement(s)
}

Step 5: Now re-export the 'url' module for changes to take effect

module.exports = url

Project Structure:

Explanation

Now let us code the "app.js" file. In it, we follow all the steps mentioned above for overriding a module. After those steps, you would have successfully overridden the format() function of 'url' module. Find the full working code below in which the behaviour of format() function before overriding and after it has been shown.

// app.js
// Requiring the in-built url module
// to override
const url = require("url");

// The default behaviour of format()
// function of url
console.log(url.format("http://localhost:3000/"));

// Deleting the format function of url
delete url["format"];

// Adding new function to url with same
// name so that it would override
url.format = function (str) {
  return "Sorry!! I don't know how to format the url";
};

// Re-exporting the module for changes
// to take effect
module.exports = url;

// The new behaviour of export() function
// of url module
console.log(url.format("http://localhost:3000/"));

Step 3: Run your node app using the following command. 

node app.js

Output: