Express Request Proxy

2.2.2 · abandoned · verified Wed Apr 22

express-request-proxy is an Express.js middleware designed for creating high-performance streaming HTTP reverse proxies. It enables features like transparent caching via Redis, server-side injection of sensitive API keys and headers, custom route parameter handling, and response transformations. The package is built upon the widely used, but now deprecated, `request` HTTP client library. Its last major release was 2.x, with version 2.2.2 being the latest. Given its dependency on the unmaintained `request` library and lack of recent updates (last commit August 2018), the package is effectively abandoned, limiting its viability for new projects and posing potential maintenance and security risks.

Common errors

```
TypeError: requestProxy is not a function
```
cause Attempting to use ES module import syntax (e.g., 'import') for a CommonJS-only package.

fix Change your import statement to CommonJS: 'const requestProxy = require("express-request-proxy");'
```
Error: Cannot find module 'request'
```
cause The 'request' dependency might be missing, or there are module resolution issues related to its deprecation and potential removal from package managers.

fix Ensure 'request' is listed in your package.json and installed. However, due to its deprecation, it's strongly recommended to migrate away from this package.
```
Redis Client Error connect ECONNREFUSED
```
cause The Redis server is not running or is inaccessible at the configured host/port, or the client was not connected before being passed to the proxy.

fix Verify your Redis server is running and configured correctly. Check the host and port in 'redis.createClient()' options, and ensure `redisClient.connect()` has been called and awaited.
```
TypeError: app.use() requires middleware functions but got a [object Object]
```
cause The configuration object passed to 'requestProxy' is invalid or incomplete, preventing it from returning a valid Express middleware function. Most commonly, the 'url' option is missing.

fix Ensure the 'url' option is always provided in the 'requestProxy' configuration object, as it is the only required option.

Warnings

breaking The core dependency, 'request' library, has been officially deprecated and is no longer maintained. This means 'express-request-proxy' inherits significant security vulnerabilities, stability issues, and lack of future updates. Using this package in production is highly discouraged.
Fix: Migrate to a modern proxy solution based on 'node-fetch', 'axios', 'undici', or 'http-proxy-middleware'.
gotcha This package is CommonJS (CJS) only. Attempting to import it using ES module syntax (e.g., 'import requestProxy from "express-request-proxy"') will lead to runtime errors.
Fix: Use 'const requestProxy = require("express-request-proxy");' for importing the middleware.
gotcha The caching feature relies on a 'redis' client that must be extended with 'redis-streams'. Incorrect setup (e.g., missing 'require("redis-streams")(redis);') will prevent caching from working or cause runtime errors.
Fix: Ensure you call 'require("redis-streams")(redis);' after requiring the 'redis' package and before creating the client used by the proxy. Also ensure the redis client is connected before passing it.
gotcha Environment variables for sensitive keys (e.g., 'SOMEAPI_SECRET_KEY') must be set in the server environment before the application starts, as 'express-request-proxy' accesses them directly via 'process.env'.
Fix: Define environment variables in your deployment environment or use a package like 'dotenv' to load them before your application script runs.
deprecated The 'request' library, which this package is built upon, is deprecated. Its API patterns (e.g., callback-based) are outdated compared to modern promise-based or async/await HTTP clients, affecting code maintainability and future compatibility.
Fix: Consider migrating to a contemporary proxy solution that uses modern HTTP clients for better maintainability and performance.

Install

npm install express-request-proxy npm
yarn add express-request-proxy yarn
pnpm add express-request-proxy pnpm

Imports

requestProxy
wrong:
```
import requestProxy from 'express-request-proxy';
```
correct:
```
const requestProxy = require('express-request-proxy');
```
This package is CommonJS only and relies on the deprecated 'request' library. Attempting ES module imports will result in errors. There are no named exports.

Quickstart

This quickstart demonstrates setting up an Express server to use `express-request-proxy` to forward requests to a public API, including server-side injection of API keys and custom headers, and utilizing Redis for caching responses.

const express = require('express');
const redis = require('redis');
const requestProxy = require('express-request-proxy');
require('redis-streams')(redis); // Extend redis client with streams functionality

const app = express();
const port = 3000;

// Create a Redis client for caching
const redisClient = redis.createClient();
redisClient.on('error', (err) => console.error('Redis Client Error', err));

// Connect to Redis (async operation)
async function connectRedis() {
  await redisClient.connect();
  console.log('Connected to Redis');
}
connectRedis();

app.get(
  '/api/:resource/:id',
  requestProxy({
    cache: redisClient, // Use the connected Redis client
    cacheMaxAge: 60, // Cache for 60 seconds
    url: 'https://jsonplaceholder.typicode.com/:resource/:id', // Example public API
    query: {
      api_key: process.env.SOMEAPI_SECRET_KEY ?? 'demo-key' // Inject sensitive key from env
    },
    headers: {
      'X-Custom-Auth': process.env.SOMEAPI_CUSTOM_HEADER ?? 'secret-value' // Inject custom header
    }
  })
);

app.get('/', (req, res) => {
    res.send('Proxy server running. Try /api/posts/1 or /api/users/2');
});

app.listen(port, () => {
  console.log(`Proxy server listening at http://localhost:${port}`);
  console.log('Test with: curl http://localhost:3000/api/posts/1');
});

view raw JSON →