When proxying an object, we can decide to intercept all of its methods or only some of them, while delegating the rest of them directly to the subject. There are several ways in which this can be achieved; let's analyze some of them.

function createProxy(subject) { 
  const proto = Object.getPrototypeOf(subject); 
 
  function Proxy(subject) { 
    this.subject = subject; 
  } 
 
  Proxy.prototype = Object.create(proto); 
 
  //proxied method 
  Proxy.prototype.hello = function(){ 
    return this.subject.hello() + ' world!'; 
  }; 
 
  //delegated method 
  Proxy.prototype.goodbye = function(){ 
    return this.subject.goodbye 
      .apply(this.subject, arguments); 
  }; 
 
  return new Proxy(subject); 
}
module.exports = createProxy; 

function createProxy(subject) { 
  return { 
    //proxied method 
    hello: () => (subject.hello() + ' world!'), 
 
    //delegated method 
    goodbye: () => (subject.goodbye.apply(subject, arguments)) 
  }; 
} 

function createProxy(subject) { 
  const helloOrig = subject.hello; 
  subject.hello = () => (helloOrig.call(this) + ' world!'); 

  return subject; 
} 

Composition can be considered the safest way of creating a proxy, because it leaves the subject untouched without mutating its original behavior. Its only drawback is that we have to manually delegate all the methods, even if we want to proxy only one of them. If needed, we might also have to delegate the access to the properties of the subject.

Object augmentation, on the other hand, modifies the subject, which might not always be what we want, but it does not present the various inconveniences related to delegation. For this reason, object augmentation is definitely the most pragmatic way to implement proxies in JavaScript, and it's the preferred technique in all those circumstances where modifying the subject is not a big concern.

However, there is at least one situation where composition is almost necessary; this is when we want to control the initialization of the subject, to, for example, create it only when needed (lazy initialization).

To see the proxy pattern in a real example, we will now build an object that acts as a proxy to a Writable stream, by intercepting all the calls to the write() method and logging a message every time this happens. We will use an object composition to implement our proxy; this is how the loggingWritable.js file looks:

function createLoggingWritable(writableOrig) { 
  const proto = Object.getPrototypeOf(writableOrig); 
 
  function LoggingWritable(writableOrig) { 
    this.writableOrig = writableOrig; 
  } 
 
  LoggingWritable.prototype = Object.create(proto); 
 
  LoggingWritable.prototype.write = function(chunk, encoding, callback) { 
    if(!callback && typeof encoding === 'function') { 
      callback = encoding; 
      encoding = undefined; 
    } 
    console.log('Writing ', chunk); 
    return this.writableOrig.write(chunk, encoding, function() { 
      console.log('Finished writing ', chunk); 
      callback && callback(); 
    }); 
  }; 
 
  LoggingWritable.prototype.on = function() { 
    return this.writableOrig.on 
      .apply(this.writableOrig, arguments); 
  }; 
 
  LoggingWritable.prototype.end = function() { 
    return this.writableOrig.end 
      .apply(this.writableOrig, arguments); 
  }; 
 
  return new LoggingWritable(writableOrig); 
} 

In the preceding code, we created a factory that returns a proxied version of the writable object passed as an argument. We provide an override for the write() method that logs a message to the standard output every time it is invoked and every time the asynchronous operation completes. This is also a good example of creating proxies of asynchronous functions, which makes proxying the callback necessary as well; this is an important detail to be considered in a platform such as Node.js. The remaining methods, on() and end(), are simply delegated to the original writable stream (to keep the code leaner we are not considering the other methods of the writable interface).

We can now include a few more lines of code into the loggingWritable.js module to test the proxy that we just created:

const fs = require('fs'); 
 
const writable = fs.createWriteStream('test.txt'); 
const writableProxy = createLoggingWritable(writable); 
 
writableProxy.write('First chunk'); 
writableProxy.write('Second chunk'); 
writable.write('This is not logged'); 
writableProxy.end(); 

The proxy did not change the original interface of the stream or its external behavior, but if we run the preceding code, we will now see that every chunk that is written into the stream is transparently logged to the console.

In its numerous forms, proxy is quite a popular pattern in Node.js, as well as in the ecosystem. In fact, we can find several libraries that allow us to simplify the creation of proxies, most of the time leveraging object augmentation as an implementation approach. In the community, this pattern can also be referred to as function hooking, or sometimes as Aspect-Oriented Programming (AOP), which is actually a common area of application for proxies. In AOP, these libraries usually allow the developer to set pre- or post-execution hooks for a specific method (or a set of methods) that allow us to execute custom code before and after the execution of the advised method, respectively.

Sometimes proxies are also called middleware, because, as it happens in the middleware pattern (which we will see later in the chapter), they allow us to pre-process and post-process the input/output of a function. Sometimes, they also allow the registering of multiple hooks for the same method using a middleware-like pipeline.

There are several libraries on npm that allow us to implement function hooks with little effort. Among them there are hooks (https://npmjs.org/package/hooks), hooker (https://npmjs.org/package/hooker), and meld (https://npmjs.org/package/meld).

The ES2015 specification introduced a global object called Proxy, which is available in Node.js starting from version 6.

The Proxy API contains a Proxy constructor that accepts a target and a handler as arguments:

const proxy = new Proxy(target, handler); 

Here, target represents the object on which the proxy is applied (the subject for our canonical definition), while handler is a special object that defines the behavior of the proxy.

The handler object contains a series of optional methods with predefined names called trap methods (for example, apply, get, set, and has) that are automatically called when the corresponding operations are performed on the proxy instance.

To better understand how this API works, let's see an example:

const scientist = { 
  name: 'nikola', 
  surname: 'tesla' 
}; 
 
const uppercaseScientist = new Proxy(scientist, { 
  get: (target, property) => target[property].toUpperCase() 
}); 
 
console.log(uppercaseScientist.name, uppercaseScientist.surname);  
  // prints NIKOLA TESLA 

In this example, we are using the Proxy API to intercept all access to the properties of the target object, scientist, and convert the original value of the property to an uppercase string.

If you look carefully at this example, you can probably notice something very peculiar about this API: it allows us to intercept access to the generic attribute in the target object. This is possible because the API is not just a simple wrapper to facilitate the creation of proxy objects, like the ones we defined in the previous sections of this chapter; instead it is a feature deeply integrated into the JavaScript language itself, which enables developers to intercept and customize many operations that can be performed on objects. This characteristic opens up new interesting scenarios that were not easily achievable before such as meta-programming, operator overloading, and object virtualization.

Let's see another example to clarify this concept:

const evenNumbers = new Proxy([], { 
  get: (target, index) => index * 2, 
  has: (target, number) => number % 2 === 0 
}); 
 
console.log(2 in evenNumbers); // true 
console.log(5 in evenNumbers); // false 
console.log(evenNumbers[7]);   // 14 

In this example, we are creating a virtual array that contains all the even numbers. It can be used as a regular array, which means we can access items in the array with the regular array syntax (for example, evenNumbers[7]), or check the existence of an element in the array with the in operator (for example, 2 in evenNumbers). The array is considered virtual because we never store data in it.

Looking at the implementation, this proxy uses an empty array as the target and then defines the traps get and has in the handler:

The Proxy API supports a number of other interesting traps such as set, delete, and construct, and allows us to create proxies that can be revoked on demand, disabling all the traps and restoring the original behavior of the target object.

Analyzing all these features goes beyond the scope of this chapter; what is important here is understanding that the Proxy API provides a powerful foundation for taking advantage of the Proxy design pattern when you need it.

Mongoose (http://mongoosejs.com) is a popular Object-Document Mapping (ODM) library for MongoDB. Internally, it uses the hooks package (https://npmjs.org/package/hooks) to provide pre-and post-execution hooks for the init, validate, save, and remove methods of its Document objects. Find out more with the official documentation at http://mongoosejs.com/docs/middleware.html.