@responsedotok/shufffle 0.1.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2026 Adam Robson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# shufffle
+
+A zero-dependency, config-driven reverse proxy for Node.js. Define routes and upstreams in JSON, run it from the CLI, or embed it in your own server.
+
+## Install
+
+```bash
+npm install @responsedotok/shufffle
+```
+
+Requires Node.js >= 22.
+
+## CLI Usage
+
+Create `proxy.config.json`:
+
+```json
+{
+  "port": 8080,
+  "balancer": "round-robin",
+  "routes": [
+    {
+      "match": "/api",
+      "rewrite": { "stripPrefix": "/api" },
+      "upstreams": [
+        { "host": "localhost", "port": 3001 },
+        { "host": "localhost", "port": 3002 }
+      ]
+    },
+    {
+      "match": "/",
+      "upstreams": [{ "host": "localhost", "port": 3000 }]
+    }
+  ]
+}
+```
+
+Run it:
+
+```bash
+npx shufffle --config ./proxy.config.json
+```
+
+CLI flags: `-c/--config`, `-l/--log-level`, `-e/--env key=value`, `-b/--balancer`, `-h/--help`.
+
+## Programmatic Usage
+
+Create an async function, import `createProxy()`, and call it with await. pass an object
+with the following shapes `{ port: number, routes: Route* }`.  instead of calling `listen()` is async and starts the server for you — `await` it; don't call `listen()` yourself.
+
+```ts
+import { createProxy } from "@responsedotok/shufffle";
+
+async function main() {
+  const proxy = await createProxy({
+    port: 8080,
+    routes: [
+      { match: "/", upstreams: [{ host: "localhost", port: 3000 }] },
+    ],
+  });
+
+  process.on("SIGTERM", () => proxy.close());
+  process.on("SIGINT", () => proxy.close());
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+```
+
+If you'd rather control the lifecycle yourself, construct the server directly:
+
+```ts
+import { ProxyServer } from "@responsedotok/shufffle";
+
+const proxy = new ProxyServer({ port: 8080, routes: [/* … */] });
+await proxy.listen();
+```
+
+## Features
+
+- Path-prefix or function-based route matching
+- Multiple upstreams per route with `round-robin`, `random`, or `weighted` load balancing
+- Path rewrites (e.g. `stripPrefix`)
+- Per-route and global header rules
+- Configurable timeouts, max body size, and `X-Forwarded-For` forwarding
+
+## License
+
+MIT

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/src/cli/help.d.ts

@@ -0,0 +1 @@
+export declare function printHelp(): void;

package/dist/cjs/src/cli/help.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHelp = printHelp;
+function printHelp() {
+    console.info(`
+    shufffle — Node Reverse Proxy
+
+    **USAGE**
+    
+    shufffle [options]
+
+
+    **OPTIONS**
+
+    -c, --config <path>      Path to config file (default: ./proxy.config.json)
+    -l, --log-level <level>  Log level: debug | info | warn | error | silent (default: info)
+    -e, --env <key=value>    Set environment variables (can be used multiple times). Variables already present
+                             in process.env are also honored. .env files are not loaded automatically — use a
+                             loader (e.g. \`node --env-file=.env\`) if you want that behavior.
+    -b, --balancer <name>    Load balancer strategy: round-robin | random | weighted (overrides config)
+    -h, --help               Show this help message
+
+    **CONFIG FORMAT**
+
+    DEFAULT CONFIG: proxy.config.json
+
+    {
+      "port": 8080,
+      "balancer": "round-robin",
+      "headers": {
+        "response": { "X-Powered-By": "shufffle" }
+      },
+      "routes": [
+        {
+          "match": "/api",
+          "rewrite": { "stripPrefix": "/api" },
+          "upstreams": [
+            { "host": "localhost", "port": 3001 },
+            { "host": "localhost", "port": 3002 }
+          ]
+        },
+        {
+          "match": "/",
+          "upstreams": [{ "host": "localhost", "port": 3000 }]
+        }
+      ]
+    }
+
+    **EXAMPLES**
+    
+    shufffle
+    shufffle --config ./config/dev.json --log-level debug
+`);
+}

package/dist/cjs/src/cli/index.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/cjs/src/cli/index.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const node_process_1 = __importDefault(require("node:process"));
+const config_js_1 = require("../config/config.js");
+const env_overrides_js_1 = require("../env-overrides.js");
+const proxy_server_js_1 = require("../lib/services/proxy/proxy-server.js");
+const logger_js_1 = require("../logger/logger.js");
+const help_js_1 = require("./help.js");
+const parse_args_js_1 = require("./parse-args.js");
+async function main() {
+    const { configPath, logLevel, help, env, balancer } = (0, parse_args_js_1.parseArgs)(node_process_1.default.argv);
+    if (help) {
+        (0, help_js_1.printHelp)();
+        node_process_1.default.exit(0);
+    }
+    for (const [k, v] of Object.entries(env)) {
+        node_process_1.default.env[k] = v;
+    }
+    const logger = new logger_js_1.Logger(logLevel);
+    let config;
+    try {
+        const loaded = await config_js_1.Config.fromFile(configPath);
+        config = (0, env_overrides_js_1.applyEnvOverrides)({ ...loaded }, (0, env_overrides_js_1.envOverrides)());
+        if (balancer)
+            config = { ...config, balancer };
+        logger.debug(`Config loaded from ${configPath}:`, { config: configPath });
+    }
+    catch (err) {
+        logger.error(`Failed to load config from ${configPath}:`, {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        node_process_1.default.exit(1);
+    }
+    const server = new proxy_server_js_1.ProxyServer(config, {
+        onRequest({ req, upstream, targetPath }) {
+            logger.debug('→ request', {
+                method: req.method,
+                url: req.url,
+                upstream: `${upstream.host}:${upstream.port}`,
+                path: targetPath,
+            });
+            return true;
+        },
+        onResponse(ctx, statusCode) {
+            logger.debug('← response', {
+                statusCode,
+                url: ctx.req.url,
+                method: ctx.req.method,
+                upstream: `${ctx.upstream.host}:${ctx.upstream.port}`,
+                path: ctx.targetPath,
+            });
+        },
+        onError(error, ctx) {
+            logger.error('✗✗✗ proxy error ✗✗✗', {
+                error: error.message,
+                url: ctx?.req?.url,
+                method: ctx?.req?.method,
+                upstream: ctx?.upstream
+                    ? `${ctx.upstream.host}:${ctx.upstream.port}`
+                    : undefined,
+                path: ctx?.targetPath,
+            });
+        },
+    });
+    await server.listen();
+    logger.debug(`Proxy server is listening on ${config.host ?? ''}:${config.port}`, {
+        port: config.port,
+        host: config.host ?? '0.0.0.0',
+        routes: config.routes.length,
+    });
+    for (const sig of ['SIGINT', 'SIGTERM', 'SIGQUIT']) {
+        node_process_1.default.on(sig, async () => {
+            logger.debug(`✗✗✗ Shut Down Mode ✗✗✗\nReceived ${sig}, Commencing shut down!`, { signal: sig });
+            try {
+                await server.close();
+                logger.debug('✗✗✗ Graceful shutdown bye ✗✗✗');
+                node_process_1.default.exit(0);
+            }
+            catch (err) {
+                logger.error('✗✗✗ Error during shutdown; what do you think mopopipo ✗✗✗', {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                node_process_1.default.exit(1);
+            }
+        });
+    }
+}
+main().catch((err) => {
+    console.error('✗✗✗ Fatal error ✗✗✗', err instanceof Error ? err.message : String(err));
+    node_process_1.default.exit(1);
+});

package/dist/cjs/src/cli/parse-args.d.ts

@@ -0,0 +1,9 @@
+import { LoadBalancerStrategy } from '../lib/types/load-balancer-strategy.js';
+import type { LogLevel } from '../lib/types/log.js';
+export declare function parseArgs(argv: string[]): {
+    configPath: string;
+    logLevel: LogLevel;
+    help: boolean;
+    env: Record<string, string>;
+    balancer?: LoadBalancerStrategy;
+};

package/dist/cjs/src/cli/parse-args.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+const load_balancer_strategy_js_1 = require("../lib/types/load-balancer-strategy.js");
+const log_js_1 = require("../lib/types/log.js");
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    let configPath = './proxy.config.json';
+    let logLevel = 'info';
+    let help = false;
+    const env = {};
+    let balancer;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--help':
+            case '-h':
+                help = true;
+                break;
+            case '--config':
+            case '-c':
+                if (i + 1 >= args.length)
+                    throw new Error(`Missing value for ${arg}`);
+                configPath = args[++i];
+                break;
+            case '--log-level':
+            case '-l': {
+                if (i + 1 >= args.length)
+                    throw new Error(`Missing value for ${arg}`);
+                const value = args[++i];
+                const valid = Object.keys(log_js_1.LEVELS);
+                if (!valid.includes(value)) {
+                    throw new Error(`Invalid value for ${arg}: ${value}. Must be one of: ${valid.join(', ')}`);
+                }
+                logLevel = value;
+                break;
+            }
+            case '--env':
+            case '-e': {
+                if (i + 1 >= args.length)
+                    throw new Error(`Missing value for ${arg}`);
+                const raw = args[++i];
+                const eq = raw.indexOf('=');
+                if (eq <= 0)
+                    throw new Error(`Invalid value for ${arg}: ${raw}`);
+                const key = raw.slice(0, eq);
+                const value = raw.slice(eq + 1);
+                env[key] = value;
+                break;
+            }
+            case '--balancer':
+            case '-b': {
+                if (i + 1 >= args.length)
+                    throw new Error(`Missing value for ${arg}`);
+                const value = args[++i];
+                const valid = Object.values(load_balancer_strategy_js_1.LoadBalancerStrategy);
+                if (!valid.includes(value)) {
+                    throw new Error(`Invalid value for ${arg}: ${value}. Must be one of: ${valid.join(', ')}`);
+                }
+                balancer = value;
+                break;
+            }
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return { configPath, logLevel, help, env, balancer };
+}

package/dist/cjs/src/config/config.d.ts

@@ -0,0 +1,16 @@
+import type { ConfigType } from '../lib/types/config.js';
+export declare class Config {
+    readonly port: number;
+    readonly host: string;
+    readonly routes: ConfigType['routes'];
+    readonly headers?: ConfigType['headers'];
+    readonly balancer?: ConfigType['balancer'];
+    readonly timeout?: ConfigType['timeout'];
+    readonly forwardIp?: ConfigType['forwardIp'];
+    readonly maxBodySize?: ConfigType['maxBodySize'];
+    readonly healthCheck?: ConfigType['healthCheck'];
+    private constructor();
+    static validate(raw: unknown, source: string): ConfigType;
+    static fromFile(filePath: string): Promise<Config>;
+    static fromObject(data: unknown, source?: string): Config;
+}

package/dist/cjs/src/config/config.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const load_balancer_strategy_js_1 = require("../lib/types/load-balancer-strategy.js");
+const VALID_BALANCERS = new Set(Object.values(load_balancer_strategy_js_1.LoadBalancerStrategy));
+const VALID_PROTOCOLS = new Set(['http', 'https']);
+function isPositiveInt(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v > 0;
+}
+function isNonNegativeInt(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 0;
+}
+class Config {
+    port;
+    host;
+    routes;
+    headers;
+    balancer;
+    timeout;
+    forwardIp;
+    maxBodySize;
+    healthCheck;
+    constructor(cfg) {
+        this.port = cfg.port;
+        this.host = cfg.host ?? '0.0.0.0';
+        this.routes = cfg.routes;
+        this.headers = cfg.headers;
+        this.balancer = cfg.balancer;
+        this.timeout = cfg.timeout;
+        this.forwardIp = cfg.forwardIp;
+        this.maxBodySize = cfg.maxBodySize;
+        this.healthCheck = cfg.healthCheck;
+    }
+    static validate(raw, source) {
+        if (!raw || typeof raw !== 'object') {
+            throw new Error(`Config in source ${source} must be an object`);
+        }
+        const conf = raw;
+        if (typeof conf.port !== 'number') {
+            throw new Error(`Config in ${source} must have a numeric 'port' property`);
+        }
+        if (conf.port < 1 || conf.port > 65535 || !Number.isInteger(conf.port)) {
+            throw new Error(`Config in ${source} PORT must be an integer between 1 and 65535.`);
+        }
+        if (conf.host !== undefined) {
+            if (typeof conf.host !== 'string' || conf.host.length === 0) {
+                throw new Error(`Config in ${source} 'host' must be a non-empty string`);
+            }
+        }
+        if (conf.balancer !== undefined && !VALID_BALANCERS.has(conf.balancer)) {
+            throw new Error(`Config in ${source} 'balancer' must be one of ${[...VALID_BALANCERS].join(', ')}, got '${conf.balancer}'`);
+        }
+        if (conf.timeout !== undefined && !isPositiveInt(conf.timeout)) {
+            throw new Error(`Config in ${source} 'timeout' must be a positive integer (ms)`);
+        }
+        if (conf.forwardIp !== undefined && typeof conf.forwardIp !== 'boolean') {
+            throw new Error(`Config in ${source} 'forwardIp' must be a boolean`);
+        }
+        if (conf.maxBodySize !== undefined && !isNonNegativeInt(conf.maxBodySize)) {
+            throw new Error(`Config in ${source} 'maxBodySize' must be a non-negative integer (bytes)`);
+        }
+        if (conf.healthCheck !== undefined) {
+            if (typeof conf.healthCheck !== 'object' || conf.healthCheck === null) {
+                throw new Error(`Config in ${source} 'healthCheck' must be an object`);
+            }
+            const { interval, timeout } = conf.healthCheck;
+            if (interval !== undefined && !isPositiveInt(interval)) {
+                throw new Error(`Config in ${source} 'healthCheck.interval' must be a positive integer (ms)`);
+            }
+            if (timeout !== undefined && !isPositiveInt(timeout)) {
+                throw new Error(`Config in ${source} 'healthCheck.timeout' must be a positive integer (ms)`);
+            }
+        }
+        if (!Array.isArray(conf.routes) || conf.routes.length === 0) {
+            throw new Error(`Config in ${source} must have a non-empty 'routes' array`);
+        }
+        for (const [i, rte] of conf.routes.entries()) {
+            if (rte.match === undefined || rte.match === null) {
+                throw new Error(`Config in ${source} is required to have routes.match at index ${i}`);
+            }
+            if (typeof rte.match !== 'string' && typeof rte.match !== 'function') {
+                throw new Error(`Config in ${source} routes.match at index ${i} must be a string or function, got ${typeof rte.match}`);
+            }
+            if (!Array.isArray(rte.upstreams) || rte.upstreams.length === 0) {
+                throw new Error(`Config in ${source} is required to have routes.upstreams at index ${i}`);
+            }
+            for (const [j, u] of rte.upstreams.entries()) {
+                if (typeof u.host !== 'string' || u.host.length === 0) {
+                    throw new Error(`Config in ${source} routes[${i}].upstreams[${j}].host must be a non-empty string`);
+                }
+                if (typeof u.port !== 'number') {
+                    throw new Error(`Config in ${source} routes[${i}].upstreams[${j}].port must be a number`);
+                }
+                if (u.port < 1 || u.port > 65535 || !Number.isInteger(u.port)) {
+                    throw new Error(`Config in ${source} upstream port must be an integer between 1 and 65535.`);
+                }
+                if (u.protocol !== undefined && !VALID_PROTOCOLS.has(u.protocol)) {
+                    throw new Error(`Config in ${source} routes[${i}].upstreams[${j}].protocol must be 'http' or 'https', got '${u.protocol}'`);
+                }
+                if (u.weight !== undefined &&
+                    (typeof u.weight !== 'number' ||
+                        !Number.isFinite(u.weight) ||
+                        u.weight <= 0)) {
+                    throw new Error(`Config in ${source} routes[${i}].upstreams[${j}].weight must be a positive number`);
+                }
+            }
+            if (rte.balancer !== undefined && !VALID_BALANCERS.has(rte.balancer)) {
+                throw new Error(`Config in ${source} routes[${i}].balancer must be one of ${[...VALID_BALANCERS].join(', ')}, got '${rte.balancer}'`);
+            }
+            if (rte.timeout !== undefined && !isPositiveInt(rte.timeout)) {
+                throw new Error(`Config in ${source} routes[${i}].timeout must be a positive integer (ms)`);
+            }
+            if (rte.maxBodySize !== undefined && !isNonNegativeInt(rte.maxBodySize)) {
+                throw new Error(`Config in ${source} routes[${i}].maxBodySize must be a non-negative integer (bytes)`);
+            }
+        }
+        return conf;
+    }
+    static async fromFile(filePath) {
+        const absolutePath = node_path_1.default.resolve(filePath);
+        const extension = node_path_1.default.extname(absolutePath).toLowerCase();
+        let raw;
+        if (extension === '.json') {
+            const contents = await promises_1.default.readFile(absolutePath, 'utf-8');
+            raw = JSON.parse(contents);
+        }
+        else if (extension === '.js' ||
+            extension === '.mjs' ||
+            extension === '.cjs') {
+            const module = (await Promise.resolve(`${(0, node_url_1.pathToFileURL)(absolutePath).href}`).then(s => __importStar(require(s))));
+            raw = module.default ?? module;
+        }
+        else {
+            throw new Error(`Unsupported config file extension: ${extension}. Supported: .json, .js, .mjs, .cjs. ` +
+                `For TypeScript configs, compile to JavaScript first or run via a TS-aware runtime.`);
+        }
+        const validated = Config.validate(raw, filePath);
+        return new Config(validated);
+    }
+    static fromObject(data, source = 'inline') {
+        const validated = Config.validate(data, source);
+        return new Config(validated);
+    }
+}
+exports.Config = Config;

package/dist/cjs/src/env-overrides.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigType } from './lib/types/config.js';
+export interface EnvOverrides {
+    host?: string;
+    port?: number;
+}
+export declare function envOverrides(): EnvOverrides;
+export declare function applyEnvOverrides(config: ConfigType, overrides: EnvOverrides): ConfigType;

package/dist/cjs/src/env-overrides.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envOverrides = envOverrides;
+exports.applyEnvOverrides = applyEnvOverrides;
+function envOverrides() {
+    const overrides = {};
+    const warnings = [];
+    const rawPort = process.env.PORT;
+    if (rawPort !== undefined) {
+        const trimmed = rawPort.trim();
+        const parsed = /^\d+$/.test(trimmed) ? Number(trimmed) : Number.NaN;
+        if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+            warnings.push(`PORT value must be an integer between 1 - 65535.\nRun picked up ${rawPort}`);
+        }
+        else {
+            overrides.port = parsed;
+        }
+    }
+    const rawHost = process.env.HOST;
+    if (rawHost !== undefined) {
+        if (rawHost.trim() === '') {
+            warnings.push(`HOST value cannot be empty.\nRun picked up ${rawHost}`);
+        }
+        else {
+            overrides.host = rawHost.trim();
+        }
+    }
+    for (const w of warnings) {
+        process.stdout.write(`--- [shufffle] WARNING --- ${w}\n`);
+    }
+    return overrides;
+}
+function applyEnvOverrides(config, overrides) {
+    if (Object.keys(overrides).length === 0)
+        return config;
+    return { ...config, ...overrides };
+}

package/dist/cjs/src/index.d.ts

@@ -0,0 +1,10 @@
+export { Config } from './config/config.js';
+export { createProxy, ProxyServer } from './lib/services/proxy/proxy-server.js';
+export type { ConfigType } from './lib/types/config.js';
+export type { Context } from './lib/types/context.js';
+export type { HeaderRules } from './lib/types/header-rules.js';
+export type { Hooks } from './lib/types/hooks.js';
+export { LoadBalancerStrategy } from './lib/types/load-balancer-strategy.js';
+export type { Route } from './lib/types/route.js';
+export type { RouteRewrite } from './lib/types/route-rewrite.js';
+export type { Upstream } from './lib/types/upstream.js';

package/dist/cjs/src/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancerStrategy = exports.ProxyServer = exports.createProxy = exports.Config = void 0;
+var config_js_1 = require("./config/config.js");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_js_1.Config; } });
+var proxy_server_js_1 = require("./lib/services/proxy/proxy-server.js");
+Object.defineProperty(exports, "createProxy", { enumerable: true, get: function () { return proxy_server_js_1.createProxy; } });
+Object.defineProperty(exports, "ProxyServer", { enumerable: true, get: function () { return proxy_server_js_1.ProxyServer; } });
+var load_balancer_strategy_js_1 = require("./lib/types/load-balancer-strategy.js");
+Object.defineProperty(exports, "LoadBalancerStrategy", { enumerable: true, get: function () { return load_balancer_strategy_js_1.LoadBalancerStrategy; } });

package/dist/cjs/src/lib/constants/hop-by-hop-headers.d.ts

@@ -0,0 +1 @@
+export declare const HOP_BY_HOP_HEADERS: Set<string>;

package/dist/cjs/src/lib/constants/hop-by-hop-headers.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOP_BY_HOP_HEADERS = void 0;
+exports.HOP_BY_HOP_HEADERS = new Set([
+    'connection',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade',
+]);

package/dist/cjs/src/lib/services/handlers/http-handler.d.ts

@@ -0,0 +1,32 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { Logger } from '../../../logger/logger.js';
+import type { ConfigType } from '../../types/config.js';
+import type { Hooks } from '../../types/hooks.js';
+import { LoadBalancerStrategy } from '../../types/load-balancer-strategy.js';
+import type { Upstream } from '../../types/upstream.js';
+import { HeadersService } from '../headers/headers-service.js';
+import type { LoadBalancer } from '../load-balancers/load-balancer.js';
+export declare class HttpHandler {
+    readonly config: ConfigType;
+    private readonly hooks;
+    private readonly balancers;
+    private readonly globalBalancer;
+    private readonly httpAgent;
+    private readonly httpsAgent;
+    private readonly healthService;
+    private readonly headersService;
+    private readonly logger;
+    constructor(config: ConfigType, hooks?: Hooks, headersService?: HeadersService, logger?: Logger);
+    start(): void;
+    stop(): void;
+    handler(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    private forward;
+    private canRetry;
+    healthyCandidates(upstreams: Upstream[]): Upstream[];
+    getBalancer(route: {
+        upstreams: Upstream[];
+        balancer?: LoadBalancerStrategy;
+    }): LoadBalancer;
+    private handleError;
+    private sendError;
+}