Enhancing Your Applications with Total.js v5 Proxy Functionality
Published: 2024-04-03 09:58:15

In the rapidly evolving field of web development, microservices are prevalent and their critical importance of high-performing and reliable proxy servers cannot be overstated. [My previous exploration](https://blog.totaljs.com/posts/1777745001ty71b/) into __Total.js__, a robust framework for web applications, uncovered its powerful proxy creation capabilities. Since then, __Total.js__ has released version 5, which brings significant updates and improvements to its proxy functionality. Today, I'm excited to delve into these updates, demonstrating how __Total.js__ continues to ease and refine the development process.

## Reflecting on the Past.

Before diving into the latest updates, let's revisit why __Total.js__ became my favorite tool for creating __proxy servers__. Its one-line setup, dependency-free nature, and ease of learning stood out amidst a sea of frameworks. __Total.js__ not only promised but also delivered a lightweight, strong, real-time, and reliable solution for my __proxy server__ needs.

## What's New in __Total.js v5__ Proxy Functionality?

__Total.js v5__ has introduced enhanced proxy functionalities, addressing bugs and expanding capabilities to offer more control and flexibility to developers. Here's what's new:

### Enhanced control with new methods

- **Check Functionality**: The new `.check()` method allows developers to execute custom logic to determine if a request should be proxied. This adds an extra layer of control, enabling use cases like conditional proxying based on request properties.

- **Pre and Post Processing**: With `.before()` and `.after()` methods, developers can now manipulate requests before they're sent and responses before they're returned to the client. This is perfect for adding custom headers, logging, or any form of request/response transformation.

- **Removing Proxy Routes**: The `.remove()` method provides the ability to dynamically remove proxy routes, offering flexibility in managing proxy behaviors at runtime.

### Refined Request Handling with Copy Types

The `.copy()` method has been updated to support three modes of operation - `none`, `replace`, and `extend` - providing finer control over how query strings are handled:

- **None**: Retains the original query string of the proxied request.
- **Replace**: Clears the original query string, proxying the request without it.
- **Extend**: Appends the original query string to the proxied path, allowing for extended functionality.

## Upgrading Your Proxy Server in __Total.js__ v5

Upgrading your proxy server to leverage these new features is simple. Here's a quick guide to get you started:

```javascript
// Define a proxy route with advanced control
PROXY('/cl/', 'https://totaljs.com')
    .check(function(ctrl) {
        // Add your custom logic here
        return true; // Return true to proceed with proxying
    })
    .before(function(uri, ctrl) {
        console.log(`Proxying request: ${uri}`);
        // Modify the request URI or the controller as needed
    })
    .after(function(response) {
        console.log('Received response:', response);
        // Manipulate the response before sending it back to the client
    });

// Dynamically remove the proxy route if needed
// PROXY('/cl/', 'https://totaljs.com').remove();
```

### Adapting to Use Cases with Copy Modes

Depending on your specific use case, you can choose how the proxy handles query strings:

```javascript
// Example usage of .copy() with different modes
PROXY('/cl/', 'https://yourdomain.com').copy('replace'); // Use 'none' or 'extend' as needed
```

### Understanding the `.copy()` method in detail

The `.copy()` method in __Total.js__ v5 allows developers to specify how the proxy server handles the original request's query string when forwarding to the target URL. This method supports three distinct modes: `none`, `replace`, and `extend`. Let's explore each mode with detailed examples to illustrate their use cases:

#### 1. `none`

The `none` mode tells the proxy to ignore the original query string entirely. This is useful when you want to proxy the request but don't need to pass any query parameters to the target URL.

**Example**:
```javascript
PROXY('/cl/', 'https://yourdomain.com').copy('none');
```

- **Request**: `GET /cl/?q=search`
- **Proxied as**: `https://yourdomain.com/`

In this mode, even if the original request contains query parameters (`?q=search`), they are not forwarded to the target URL.

#### 2. `replace`

The `replace` mode is used when you want to replace the path of the original request with the proxy path, but without carrying over the query string.

**Example**:
```javascript
PROXY('/cl/', 'https://yourdomain.com').copy('replace');
```
- **Request**: `GET /cl/?q=search`
- **Proxied as**: `https://yourdomain.com/`

- **Request**: `GET /cl/something/?q=search`
- **Proxied as**: `https://yourdomain.com/something/`

In `replace` mode, the path after the proxy endpoint (`/cl/`) is appended to the target URL. However, the query string from the original request is not included.

#### 3. `extend`

The `extend` mode combines the path and query string from the original request and appends them to the target URL. This is particularly useful for APIs where you need to maintain the integrity of the original request.

**Example**:
```javascript
PROXY('/cl/', 'https://yourdomain.com').copy('extend');
```
- **Request**: `GET /cl/?q=search`
- **Proxied as**: `https://yourdomain.com/?q=search`

- **Request**: `GET /cl/something/?q=search`
- **Proxied as**: `https://yourdomain.com/something/?q=search`

Here, both the path and query parameters of the original request are preserved and appended to the target URL, making it an ideal choice for scenarios where every part of the request is essential for the recipient.

### Choosing the Right Mode

Selecting the appropriate mode depends on your specific use case:

- Use `none` when the target URL does not require any query parameters from the original request.
- Opt for `replace` when you need to maintain the path but not the query parameters.
- Choose `extend` when both the path and query parameters are crucial for the target URL to process the request correctly.

Understanding these modes and their applications ensures that you can tailor the proxy behavior to fit your application's needs precisely, enhancing both functionality and user experience.


__Total.js v5__ significantly expands the capabilities of its proxy functionality, providing developers with more tools and options to create efficient, flexible, and powerful proxy servers. Whether you're building microservices, handling complex routing, or simply need a proxy for development purposes, __Total.js v5__ offers the features and flexibility needed to get the job done.

Explore these new features and see how they can enhance your __Total.js__ applications. Happy coding!

- [Join __Total.js Telegram community__](https://t.me/totaljs)