@responsedotok/shufffle 0.1.0

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

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHandler = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const logger_js_1 = require("../../../logger/logger.js");
+const match_route_js_1 = require("../../../utils/match-route.js");
+const rewrite_path_js_1 = require("../../../utils/rewrite-path.js");
+const load_balancer_strategy_js_1 = require("../../types/load-balancer-strategy.js");
+const headers_service_js_1 = require("../headers/headers-service.js");
+const health_service_js_1 = require("../health/health-service.js");
+const create_balancer_js_1 = require("../load-balancers/create-balancer.js");
+const RETRY_SAFE_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+class HttpHandler {
+    config;
+    hooks;
+    balancers = new Map();
+    globalBalancer;
+    httpAgent = new node_http_1.default.Agent({ keepAlive: true });
+    httpsAgent = new node_https_1.default.Agent({ keepAlive: true });
+    healthService;
+    headersService;
+    logger;
+    constructor(config, hooks = {}, headersService, logger) {
+        this.config = config;
+        this.hooks = hooks;
+        this.logger = logger ?? new logger_js_1.Logger();
+        this.globalBalancer = (0, create_balancer_js_1.createBalancer)(config.balancer ?? load_balancer_strategy_js_1.LoadBalancerStrategy.RoundRobin);
+        this.headersService =
+            headersService ??
+                new headers_service_js_1.HeadersService(config.headers, config.forwardIp ?? true);
+        const allUpstreams = [
+            ...new Map(config.routes
+                .flatMap((r) => r.upstreams)
+                .map((u) => [`${u.host}:${u.port}`, u])).values(),
+        ];
+        this.healthService = new health_service_js_1.HealthService(allUpstreams, config.healthCheck?.interval, config.healthCheck?.timeout);
+    }
+    start() {
+        this.healthService.start();
+    }
+    stop() {
+        this.healthService.stop();
+    }
+    async handler(req, res) {
+        const url = new URL(req.url ?? '/', 'http://localhost');
+        const pathname = url.pathname;
+        const route = (0, match_route_js_1.matchRoute)(this.config.routes, pathname);
+        if (!route) {
+            this.sendError(res, 502, 'Bad Gateway');
+            return;
+        }
+        const maxBodySize = route.maxBodySize ?? this.config.maxBodySize;
+        if (maxBodySize !== undefined) {
+            const contentLength = Number(req.headers['content-length']);
+            if (!Number.isNaN(contentLength) && contentLength > maxBodySize) {
+                req.resume();
+                this.sendError(res, 413, 'Payload too large.');
+                return;
+            }
+        }
+        const candidates = this.healthyCandidates(route.upstreams);
+        if (candidates.length === 0) {
+            await this.handleError(new Error(`No upstreams configured for route '${pathname}'`), { req, route }, res);
+            return;
+        }
+        const balancer = this.getBalancer(route);
+        const upstream = balancer.pick(candidates);
+        const targetPath = (0, rewrite_path_js_1.rewritePath)(pathname, route.rewrite) + (url.search ?? '');
+        const ctx = { req, res, route, upstream, targetPath };
+        if (this.hooks.onRequest) {
+            try {
+                const proceed = await this.hooks.onRequest({
+                    req,
+                    route,
+                    upstream,
+                    targetPath,
+                });
+                if (!proceed) {
+                    this.sendError(res, 403, 'Forbidden');
+                    return;
+                }
+            }
+            catch (err) {
+                await this.handleError(err instanceof Error ? err : new Error(String(err)), ctx, res);
+                return;
+            }
+        }
+        await this.forward(ctx, new Set([upstream]));
+    }
+    forward(ctx, tried) {
+        return new Promise((resolve) => {
+            const { req, res, upstream, targetPath, route } = ctx;
+            const protocol = upstream.protocol ?? 'http';
+            const transport = protocol === 'https' ? node_https_1.default : node_http_1.default;
+            const forwardHeaders = this.headersService.buildRequestHeaders(req, route.headers, upstream);
+            const options = {
+                hostname: upstream.host,
+                port: upstream.port,
+                method: req.method,
+                path: targetPath,
+                headers: forwardHeaders,
+                timeout: route.timeout ?? this.config.timeout ?? 30000,
+                agent: protocol === 'https' ? this.httpsAgent : this.httpAgent,
+            };
+            const proxyReq = transport.request(options, (proxyRes) => {
+                res.statusCode = proxyRes.statusCode ?? 502;
+                for (const [k, v] of Object.entries(proxyRes.headers)) {
+                    if (v !== undefined)
+                        res.setHeader(k, v);
+                }
+                this.headersService.applyResponseHeaders(res, route.headers);
+                proxyRes.on('error', (err) => {
+                    this.handleError(err, ctx, res).then(resolve);
+                });
+                if (this.hooks.onResponse) {
+                    Promise.resolve(this.hooks.onResponse(ctx, res.statusCode)).then(() => {
+                        proxyRes.pipe(res, { end: true });
+                        proxyRes.on('end', resolve);
+                    }, (err) => this.handleError(err instanceof Error ? err : new Error(String(err)), ctx, res).then(resolve));
+                }
+                else {
+                    proxyRes.pipe(res, { end: true });
+                    proxyRes.on('end', resolve);
+                }
+            });
+            proxyReq.on('timeout', () => {
+                proxyReq.destroy();
+                this.handleError(new Error(`Upstream request timed out ${upstream.host}:${upstream.port}`), ctx, res).then(resolve);
+            });
+            let bodyTooLarge = false;
+            let bodyConsumed = false;
+            proxyReq.on('error', (err) => {
+                if (bodyTooLarge) {
+                    if (!res.headersSent)
+                        this.sendError(res, 413, 'Payload Too Large');
+                    resolve();
+                    return;
+                }
+                if (!res.headersSent && this.canRetry(req, bodyConsumed)) {
+                    tried.add(upstream);
+                    const remaining = route.upstreams.filter((u) => !tried.has(u));
+                    const healthyRemaining = remaining.filter((u) => this.healthService.isHealthy(u));
+                    const candidates = healthyRemaining.length > 0 ? healthyRemaining : remaining;
+                    if (candidates.length > 0) {
+                        const balancer = this.getBalancer(route);
+                        const nextUpstream = balancer.pick(candidates);
+                        const nextCtx = { ...ctx, upstream: nextUpstream };
+                        this.forward(nextCtx, tried).then(resolve);
+                        return;
+                    }
+                }
+                this.handleError(err, ctx, res).then(resolve);
+            });
+            req.on('error', (err) => {
+                this.handleError(err, ctx, res).then(resolve);
+            });
+            const maxBodySize = route.maxBodySize ?? this.config.maxBodySize;
+            let bodyBytes = 0;
+            req.on('data', (chunk) => {
+                bodyConsumed = true;
+                if (maxBodySize === undefined)
+                    return;
+                bodyBytes += chunk.length;
+                if (!bodyTooLarge && bodyBytes > maxBodySize) {
+                    bodyTooLarge = true;
+                    req.resume();
+                    proxyReq.destroy();
+                }
+            });
+            req.pipe(proxyReq, { end: true });
+        });
+    }
+    canRetry(req, bodyConsumed) {
+        if (bodyConsumed)
+            return false;
+        const method = (req.method ?? 'GET').toUpperCase();
+        if (!RETRY_SAFE_METHODS.has(method))
+            return false;
+        const clRaw = req.headers['content-length'];
+        const clStr = Array.isArray(clRaw) ? clRaw[0] : clRaw;
+        if (clStr !== undefined) {
+            const clNum = Number(clStr);
+            if (!Number.isFinite(clNum) || clNum !== 0)
+                return false;
+        }
+        if (req.headers['transfer-encoding'])
+            return false;
+        return true;
+    }
+    healthyCandidates(upstreams) {
+        const healthy = upstreams.filter((u) => this.healthService.isHealthy(u));
+        return healthy.length > 0 ? healthy : upstreams;
+    }
+    getBalancer(route) {
+        if (!route.balancer)
+            return this.globalBalancer;
+        if (!this.balancers.has(route)) {
+            this.balancers.set(route, (0, create_balancer_js_1.createBalancer)(route.balancer));
+        }
+        return this.balancers.get(route) ?? this.globalBalancer;
+    }
+    async handleError(err, ctx, res) {
+        if (!res.headersSent) {
+            this.sendError(res, 502, 'Bad Gateway');
+        }
+        try {
+            await this.hooks.onError?.(err, ctx);
+        }
+        catch (hookErr) {
+            this.logger.error('hooks.onError threw', {
+                message: String(hookErr),
+            });
+        }
+    }
+    sendError(res, status, message) {
+        if (res.headersSent)
+            return;
+        res.writeHead(status, { 'content-type': 'text/plain' });
+        res.end(`${status} ${message}`);
+    }
+}
+exports.HttpHandler = HttpHandler;

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

@@ -0,0 +1,11 @@
+import type { IncomingMessage } from 'node:http';
+import net from 'node:net';
+import type { HeadersService } from '../headers/headers-service.js';
+import type { HttpHandler } from './http-handler.js';
+export declare class WebSocketHandler {
+    private readonly httpHandler;
+    private readonly headersService;
+    constructor(httpHandler: HttpHandler, headersService: HeadersService);
+    upgrade(req: IncomingMessage, socket: net.Socket, head: Buffer): Promise<void>;
+    private fail;
+}

package/dist/cjs/src/lib/services/handlers/websocket-handler.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHandler = void 0;
+const node_net_1 = __importDefault(require("node:net"));
+const node_tls_1 = __importDefault(require("node:tls"));
+const match_route_js_1 = require("../../../utils/match-route.js");
+const rewrite_path_js_1 = require("../../../utils/rewrite-path.js");
+class WebSocketHandler {
+    httpHandler;
+    headersService;
+    constructor(httpHandler, headersService) {
+        this.httpHandler = httpHandler;
+        this.headersService = headersService;
+    }
+    upgrade(req, socket, head) {
+        return new Promise((resolve, reject) => {
+            const { config } = this.httpHandler;
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            const route = (0, match_route_js_1.matchRoute)(config.routes, url.pathname);
+            if (!route || route.upstreams.length === 0) {
+                this.fail(socket, 502, 'Bad Gateway');
+                reject(new Error(route
+                    ? `No upstreams configured for route '${url.pathname}'`
+                    : `No matching route for WebSocket upgrade '${url.pathname}'`));
+                return;
+            }
+            const candidates = this.httpHandler.healthyCandidates(route.upstreams);
+            const upstream = this.httpHandler.getBalancer(route).pick(candidates);
+            const targetPath = (0, rewrite_path_js_1.rewritePath)(url.pathname, route.rewrite) + (url.search ?? '');
+            const upgradeHeaders = this.headersService.buildUpgradeHeaders(req, route.headers, upstream);
+            const requestLine = `${req.method ?? 'GET'} ${targetPath} HTTP/1.1\r\n`;
+            const headerBlock = `${Object.entries(upgradeHeaders)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => `${k}: ${Array.isArray(v) ? v.join(', ') : v}`)
+                .join('\r\n')}\r\n\r\n`;
+            const useTls = upstream.protocol === 'https';
+            const connectOptions = { host: upstream.host, port: upstream.port };
+            let settled = false;
+            let connected = false;
+            const teardown = () => {
+                upstreamSocket.setTimeout(0);
+                if (!socket.destroyed)
+                    socket.destroy();
+                if (!upstreamSocket.destroyed)
+                    upstreamSocket.destroy();
+            };
+            const settleResolve = () => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve();
+            };
+            const fail = (err) => {
+                if (settled) {
+                    teardown();
+                    return;
+                }
+                settled = true;
+                if (!connected) {
+                    this.fail(socket, 502, 'Bad Gateway');
+                    upstreamSocket.setTimeout(0);
+                    if (!upstreamSocket.destroyed)
+                        upstreamSocket.destroy();
+                }
+                else {
+                    teardown();
+                }
+                reject(err);
+            };
+            const onConnect = () => {
+                connected = true;
+                upstreamSocket.setTimeout(0);
+                upstreamSocket.write(requestLine + headerBlock);
+                if (head.length > 0)
+                    upstreamSocket.write(head);
+                socket.pipe(upstreamSocket);
+                upstreamSocket.pipe(socket);
+                settleResolve();
+            };
+            const upstreamSocket = useTls
+                ? node_tls_1.default.connect(connectOptions, onConnect)
+                : node_net_1.default.createConnection(connectOptions, onConnect);
+            upstreamSocket.on('error', (err) => fail(err instanceof Error ? err : new Error(String(err))));
+            upstreamSocket.setTimeout(route.timeout ?? config.timeout ?? 30000, () => fail(new Error(`Upstream WebSocket connection timed out ${upstream.host}:${upstream.port}`)));
+            socket.on('error', (err) => fail(err instanceof Error ? err : new Error(String(err))));
+            socket.on('close', teardown);
+            upstreamSocket.on('close', teardown);
+        });
+    }
+    fail(socket, status, message) {
+        if (!socket.destroyed && socket.writable) {
+            socket.write(`HTTP/1.1 ${status} ${message}\r\n\r\n`);
+        }
+        socket.destroy();
+    }
+}
+exports.WebSocketHandler = WebSocketHandler;

package/dist/cjs/src/lib/services/headers/headers-service.d.ts

@@ -0,0 +1,18 @@
+import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'node:http';
+import type { HeaderRules } from '../../types/header-rules.js';
+export declare class HeadersService {
+    private readonly globalRules;
+    private readonly forwardIp;
+    constructor(globalRules: HeaderRules | undefined, forwardIp: boolean);
+    buildRequestHeaders(req: IncomingMessage, routeRules: HeaderRules | undefined, upstream: {
+        host: string;
+        port: number;
+    }): IncomingHttpHeaders;
+    buildUpgradeHeaders(req: IncomingMessage, routeRules: HeaderRules | undefined, upstream: {
+        host: string;
+        port: number;
+    }): IncomingHttpHeaders;
+    applyResponseHeaders(res: ServerResponse, routeRules: HeaderRules | undefined): void;
+    private stripHopByHop;
+    private applyRules;
+}

package/dist/cjs/src/lib/services/headers/headers-service.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadersService = void 0;
+const hop_by_hop_headers_js_1 = require("../../constants/hop-by-hop-headers.js");
+class HeadersService {
+    globalRules;
+    forwardIp;
+    constructor(globalRules, forwardIp) {
+        this.globalRules = globalRules;
+        this.forwardIp = forwardIp;
+    }
+    buildRequestHeaders(req, routeRules, upstream) {
+        const headers = { ...req.headers };
+        this.stripHopByHop(headers);
+        headers.host = `${upstream.host}:${upstream.port}`;
+        if (this.forwardIp) {
+            const existing = headers['x-forwarded-for'];
+            const clientIp = req.socket.remoteAddress ?? 'unknown';
+            const existingStr = Array.isArray(existing)
+                ? existing.join(', ')
+                : existing;
+            headers['x-forwarded-for'] = existingStr
+                ? `${existingStr}, ${clientIp}`
+                : clientIp;
+            headers['x-forwarded-proto'] ??= req.socket
+                .encrypted
+                ? 'https'
+                : 'http';
+            headers['x-forwarded-host'] ??= req.headers.host ?? '';
+        }
+        this.applyRules(headers, this.globalRules, 'request');
+        this.applyRules(headers, routeRules, 'request');
+        return headers;
+    }
+    buildUpgradeHeaders(req, routeRules, upstream) {
+        const headers = this.buildRequestHeaders(req, routeRules, upstream);
+        if (req.headers.upgrade)
+            headers.upgrade = req.headers.upgrade;
+        headers.connection = req.headers.connection ?? 'Upgrade';
+        if (req.headers['sec-websocket-key']) {
+            headers['sec-websocket-key'] = req.headers['sec-websocket-key'];
+        }
+        if (req.headers['sec-websocket-version']) {
+            headers['sec-websocket-version'] = req.headers['sec-websocket-version'];
+        }
+        if (req.headers['sec-websocket-protocol']) {
+            headers['sec-websocket-protocol'] = req.headers['sec-websocket-protocol'];
+        }
+        if (req.headers['sec-websocket-extensions']) {
+            headers['sec-websocket-extensions'] =
+                req.headers['sec-websocket-extensions'];
+        }
+        return headers;
+    }
+    applyResponseHeaders(res, routeRules) {
+        for (const key of [
+            ...(this.globalRules?.removeResponse ?? []),
+            ...(routeRules?.removeResponse ?? []),
+        ]) {
+            res.removeHeader(key.toLowerCase());
+        }
+        for (const rules of [this.globalRules?.response, routeRules?.response]) {
+            if (!rules)
+                continue;
+            for (const [key, value] of Object.entries(rules)) {
+                res.setHeader(key.toLowerCase(), value);
+            }
+        }
+    }
+    stripHopByHop(headers) {
+        const cxn = headers.connection;
+        if (typeof cxn === 'string') {
+            for (const name of cxn.split(',')) {
+                delete headers[name.trim().toLowerCase()];
+            }
+        }
+        for (const name of hop_by_hop_headers_js_1.HOP_BY_HOP_HEADERS) {
+            delete headers[name];
+        }
+    }
+    applyRules(headers, rules, direction) {
+        if (!rules)
+            return;
+        const removeKey = direction === 'request' ? 'removeRequest' : 'removeResponse';
+        const addKey = direction;
+        for (const key of rules[removeKey] ?? []) {
+            delete headers[key.toLowerCase()];
+        }
+        for (const [key, value] of Object.entries(rules[addKey] ?? {})) {
+            headers[key.toLowerCase()] = value;
+        }
+    }
+}
+exports.HeadersService = HeadersService;

package/dist/cjs/src/lib/services/health/health-service.d.ts

@@ -0,0 +1,15 @@
+import type { Upstream } from '../../types/upstream.js';
+export declare class HealthService {
+    private readonly upstreams;
+    private readonly interval;
+    private readonly timeout;
+    private readonly unhealthy;
+    private readonly timers;
+    private started;
+    constructor(upstreams: Upstream[], interval?: number, timeout?: number);
+    start(): void;
+    stop(): void;
+    isHealthy(u: Upstream): boolean;
+    private key;
+    private probe;
+}

package/dist/cjs/src/lib/services/health/health-service.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthService = void 0;
+const node_net_1 = __importDefault(require("node:net"));
+class HealthService {
+    upstreams;
+    interval;
+    timeout;
+    unhealthy = new Set();
+    timers = [];
+    started = false;
+    constructor(upstreams, interval = 30000, timeout = 5000) {
+        this.upstreams = upstreams;
+        this.interval = interval;
+        this.timeout = timeout;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        for (const u of this.upstreams) {
+            this.probe(u);
+            const timer = setInterval(() => this.probe(u), this.interval);
+            timer.unref();
+            this.timers.push(timer);
+        }
+    }
+    stop() {
+        for (const t of this.timers) {
+            clearInterval(t);
+        }
+        this.timers.length = 0;
+        this.started = false;
+    }
+    isHealthy(u) {
+        return !this.unhealthy.has(this.key(u));
+    }
+    key(u) {
+        return `${u.host}:${u.port}`;
+    }
+    probe(u) {
+        const key = this.key(u);
+        const socket = node_net_1.default.createConnection({
+            host: u.host,
+            port: u.port,
+        });
+        socket.setTimeout(this.timeout);
+        socket.on('connect', () => {
+            this.unhealthy.delete(key);
+            socket.destroy();
+        });
+        socket.on('error', () => {
+            this.unhealthy.add(key);
+            socket.destroy();
+        });
+        socket.on('timeout', () => {
+            this.unhealthy.add(key);
+            socket.destroy();
+        });
+    }
+}
+exports.HealthService = HealthService;

package/dist/cjs/src/lib/services/load-balancers/create-balancer.d.ts

@@ -0,0 +1,3 @@
+import { LoadBalancerStrategy } from '../../types/load-balancer-strategy.js';
+import type { LoadBalancer } from './load-balancer.js';
+export declare function createBalancer(strategy: LoadBalancerStrategy): LoadBalancer;

package/dist/cjs/src/lib/services/load-balancers/create-balancer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBalancer = createBalancer;
+const load_balancer_strategy_js_1 = require("../../types/load-balancer-strategy.js");
+const random_balancer_js_1 = require("./random-balancer.js");
+const round_robin_balancer_js_1 = require("./round-robin-balancer.js");
+const weighted_balancer_js_1 = require("./weighted-balancer.js");
+function createBalancer(strategy) {
+    switch (strategy) {
+        case load_balancer_strategy_js_1.LoadBalancerStrategy.RoundRobin:
+            return new round_robin_balancer_js_1.RoundRobinBalancer();
+        case load_balancer_strategy_js_1.LoadBalancerStrategy.Random:
+            return new random_balancer_js_1.RandomBalancer();
+        case load_balancer_strategy_js_1.LoadBalancerStrategy.Weighted:
+            return new weighted_balancer_js_1.WeightedBalancer();
+        default: {
+            const exhaustive = strategy;
+            throw new Error(`Unknown load balancer strategy: ${exhaustive}`);
+        }
+    }
+}

package/dist/cjs/src/lib/services/load-balancers/load-balancer.d.ts

@@ -0,0 +1,4 @@
+import type { Upstream } from '../../types/upstream.js';
+export declare abstract class LoadBalancer {
+    abstract pick(upstreams: Upstream[]): Upstream;
+}

package/dist/cjs/src/lib/services/load-balancers/load-balancer.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancer = void 0;
+class LoadBalancer {
+}
+exports.LoadBalancer = LoadBalancer;

package/dist/cjs/src/lib/services/load-balancers/random-balancer.d.ts

@@ -0,0 +1,5 @@
+import type { Upstream } from '../../types/upstream.js';
+import { LoadBalancer } from './load-balancer.js';
+export declare class RandomBalancer extends LoadBalancer {
+    pick(upstreams: Upstream[]): Upstream;
+}

package/dist/cjs/src/lib/services/load-balancers/random-balancer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomBalancer = void 0;
+const load_balancer_js_1 = require("./load-balancer.js");
+class RandomBalancer extends load_balancer_js_1.LoadBalancer {
+    pick(upstreams) {
+        if (upstreams.length === 0) {
+            throw new Error('No upstreams available');
+        }
+        const randomIndex = Math.floor(Math.random() * upstreams.length);
+        return upstreams[randomIndex];
+    }
+}
+exports.RandomBalancer = RandomBalancer;

package/dist/cjs/src/lib/services/load-balancers/round-robin-balancer.d.ts

@@ -0,0 +1,6 @@
+import type { Upstream } from '../../types/upstream.js';
+import { LoadBalancer } from './load-balancer.js';
+export declare class RoundRobinBalancer extends LoadBalancer {
+    private idx;
+    pick(upstreams: Upstream[]): Upstream;
+}

package/dist/cjs/src/lib/services/load-balancers/round-robin-balancer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoundRobinBalancer = void 0;
+const load_balancer_js_1 = require("./load-balancer.js");
+class RoundRobinBalancer extends load_balancer_js_1.LoadBalancer {
+    idx = 0;
+    pick(upstreams) {
+        if (upstreams.length === 0) {
+            throw new Error('No upstreams available');
+        }
+        const upstream = upstreams[this.idx % upstreams.length];
+        this.idx = (this.idx + 1) % upstreams.length;
+        return upstream;
+    }
+}
+exports.RoundRobinBalancer = RoundRobinBalancer;

package/dist/cjs/src/lib/services/load-balancers/weighted-balancer.d.ts

@@ -0,0 +1,5 @@
+import type { Upstream } from '../../types/upstream.js';
+import { LoadBalancer } from './load-balancer.js';
+export declare class WeightedBalancer extends LoadBalancer {
+    pick(upstreams: Upstream[]): Upstream;
+}

package/dist/cjs/src/lib/services/load-balancers/weighted-balancer.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeightedBalancer = void 0;
+const load_balancer_js_1 = require("./load-balancer.js");
+class WeightedBalancer extends load_balancer_js_1.LoadBalancer {
+    pick(upstreams) {
+        if (upstreams.length === 0) {
+            throw new Error('No upstreams available');
+        }
+        const weights = upstreams.map((upstream) => {
+            const weight = upstream.weight ?? 1;
+            if (!Number.isFinite(weight) || weight <= 0) {
+                throw new Error('WeightedBalancer.pick() requires all upstream weights to be positive finite numbers.');
+            }
+            return weight;
+        });
+        const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+        let random = Math.random() * totalWeight;
+        for (let i = 0; i < upstreams.length; i++) {
+            random -= weights[i];
+            if (random <= 0)
+                return upstreams[i];
+        }
+        return upstreams[upstreams.length - 1];
+    }
+}
+exports.WeightedBalancer = WeightedBalancer;