ninja-reverse-proxy 1.0.3 → 1.0.5

package/dist/cache/stores/hybrid.cache.js

@@ -0,0 +1,36 @@
+import { InMemoryLRU } from './in-memory-lru.js';
+export class HybridCache {
+    l2;
+    defaultTtl;
+    l1;
+    constructor(l2, l1MaxSize, defaultTtl) {
+        this.l2 = l2;
+        this.defaultTtl = defaultTtl;
+        this.l1 = new InMemoryLRU(l1MaxSize);
+    }
+    async get(key) {
+        const l1val = this.l1.get(key);
+        if (l1val !== null)
+            return l1val;
+        const l2val = await this.l2.get(key);
+        if (l2val !== null)
+            this.l1.set(key, l2val, this.defaultTtl);
+        return l2val;
+    }
+    async set(key, value, ttlSeconds = this.defaultTtl) {
+        this.l1.set(key, value, ttlSeconds);
+        await this.l2.set(key, value, ttlSeconds);
+    }
+    async del(key) {
+        this.l1.del(key);
+        await this.l2.del(key);
+    }
+    async invalidate(pattern) {
+        this.l1.invalidatePattern(pattern);
+        await this.l2.invalidate(pattern);
+    }
+    buildKey(method, path) {
+        return this.l2.buildKey(method, path);
+    }
+}
+//# sourceMappingURL=hybrid.cache.js.map

package/dist/cache/stores/hybrid.cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybrid.cache.js","sourceRoot":"","sources":["../../../src/cache/stores/hybrid.cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,OAAO,WAAW;IAEF;IAAuC;IADnD,EAAE,CAAc;IACxB,YAAoB,EAAU,EAAE,SAAiB,EAAU,UAAkB;QAAzD,OAAE,GAAF,EAAE,CAAQ;QAA6B,eAAU,GAAV,UAAU,CAAQ;QAC3E,IAAI,CAAC,EAAE,GAAG,IAAI,WAAW,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IACD,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAG,KAAK,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAChC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACrC,IAAG,KAAK,KAAK,IAAI;YAAE,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAC5D,OAAO,KAAK,CAAE;IAChB,CAAC;IACD,KAAK,CAAC,GAAG,CAAC,GAAW,EAAE,KAAa,EAAE,UAAU,GAAG,IAAI,CAAC,UAAU;QAChE,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;QACpC,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;IAC5C,CAAC;IACD,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjB,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,KAAK,CAAC,UAAU,CAAC,OAAe;QAC9B,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QACnC,MAAM,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IACD,QAAQ,CAAC,MAAc,EAAE,IAAY;QACnC,OAAO,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACxC,CAAC;CACF"}

package/dist/cache/stores/in-memory-lru.d.ts

@@ -0,0 +1,14 @@
+export declare class InMemoryLRU {
+    private maxSize;
+    private cache;
+    constructor(maxSize: number);
+    get(key: string): string | null;
+    set(key: string, value: string, ttlSeconds: number): void;
+    del(key: string): void;
+    invalidatePattern(pattern: string): void;
+    getStats(): {
+        size: number;
+        maxSize: number;
+    };
+}
+//# sourceMappingURL=in-memory-lru.d.ts.map

package/dist/cache/stores/in-memory-lru.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-lru.d.ts","sourceRoot":"","sources":["../../../src/cache/stores/in-memory-lru.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAW;IAGV,OAAO,CAAC,OAAO;IAF3B,OAAO,CAAC,KAAK,CAAyD;gBAElD,OAAO,EAAE,MAAM;IACnC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAW/B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAOlD,GAAG,CAAC,GAAG,EAAE,MAAM;IAGf,iBAAiB,CAAC,OAAO,EAAE,MAAM;IAMjC,QAAQ;;;;CAGT"}

package/dist/cache/stores/in-memory-lru.js

@@ -0,0 +1,41 @@
+export class InMemoryLRU {
+    maxSize;
+    cache = new Map();
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expires) {
+            this.cache.delete(key);
+            return null;
+        }
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.value;
+    }
+    set(key, value, ttlSeconds) {
+        if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined)
+                this.cache.delete(firstKey);
+        }
+        this.cache.set(key, { value, expires: Date.now() + ttlSeconds * 1000 });
+    }
+    del(key) {
+        this.cache.delete(key);
+    }
+    invalidatePattern(pattern) {
+        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+        for (const key of this.cache.keys()) {
+            if (regex.test(key))
+                this.cache.delete(key);
+        }
+    }
+    getStats() {
+        return { size: this.cache.size, maxSize: this.maxSize };
+    }
+}
+//# sourceMappingURL=in-memory-lru.js.map

package/dist/cache/stores/in-memory-lru.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-lru.js","sourceRoot":"","sources":["../../../src/cache/stores/in-memory-lru.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,WAAW;IAGF;IAFZ,KAAK,GAAG,IAAI,GAAG,EAA8C,CAAC;IAEtE,YAAoB,OAAe;QAAf,YAAO,GAAP,OAAO,CAAQ;IAAE,CAAC;IACtC,GAAG,CAAC,GAAW;QACb,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAG,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC;QACvB,IAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,OAAO,EAAC,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACvB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC3B,OAAO,KAAK,CAAC,KAAK,CAAC;IACrB,CAAC;IACD,GAAG,CAAC,GAAW,EAAE,KAAa,EAAE,UAAkB;QAChD,IAAG,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,EAAC,CAAC;YAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;YAChD,IAAG,QAAQ,KAAK,SAAS;gBAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,UAAU,GAAG,IAAI,EAAE,CAAC,CAAC;IAC1E,CAAC;IACD,GAAG,CAAC,GAAW;QACb,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,iBAAiB,CAAC,OAAe;QAC/B,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;QACvD,KAAI,MAAM,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,EAAC,CAAC;YAClC,IAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;gBAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IACD,QAAQ;QACN,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC;IAC1D,CAAC;CACF"}

package/dist/cache/stores/redis.cache.d.ts

@@ -0,0 +1,13 @@
+import type { ICache } from "../contracts/cache.interface.js";
+import type { RedisClientType } from "redis";
+export declare class RedisCache implements ICache {
+    private client;
+    private defaultTtl;
+    constructor(client: RedisClientType, defaultTtl: number);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttlSeconds?: number): Promise<void>;
+    del(key: string): Promise<void>;
+    invalidate(pattern: string): Promise<void>;
+    buildKey(method: string, path: string): string;
+}
+//# sourceMappingURL=redis.cache.d.ts.map

package/dist/cache/stores/redis.cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.cache.d.ts","sourceRoot":"","sources":["../../../src/cache/stores/redis.cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAE7C,qBAAa,UAAW,YAAW,MAAM;IAErC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;gBADV,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,MAAM;IAEtB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAGxC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,SAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAG5E,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAG/B,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBhD,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;CAG/C"}

package/dist/cache/stores/redis.cache.js

@@ -0,0 +1,39 @@
+export class RedisCache {
+    client;
+    defaultTtl;
+    constructor(client, defaultTtl) {
+        this.client = client;
+        this.defaultTtl = defaultTtl;
+    }
+    async get(key) {
+        return this.client.get(key);
+    }
+    async set(key, value, ttlSeconds = this.defaultTtl) {
+        await this.client.set(key, value, { EX: ttlSeconds });
+    }
+    async del(key) {
+        await this.client.del(key);
+    }
+    async invalidate(pattern) {
+        const searchPatterns = pattern.includes("*")
+            ? [pattern, `*${pattern}*`, `proxy:*:${pattern}`]
+            : [`proxy:*:${pattern}`, `*${pattern}*`];
+        const allKeys = new Set();
+        for (const p of searchPatterns) {
+            try {
+                const keys = await this.client.keys(p);
+                keys.forEach((k) => allKeys.add(k));
+            }
+            catch {
+                // ignore individual pattern failures
+            }
+        }
+        if (allKeys.size > 0) {
+            await this.client.del([...allKeys]);
+        }
+    }
+    buildKey(method, path) {
+        return `proxy:${method}:${path}`;
+    }
+}
+//# sourceMappingURL=redis.cache.js.map

package/dist/cache/stores/redis.cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.cache.js","sourceRoot":"","sources":["../../../src/cache/stores/redis.cache.ts"],"names":[],"mappings":"AAGA,MAAM,OAAO,UAAU;IAEX;IACA;IAFV,YACU,MAAuB,EACvB,UAAkB;QADlB,WAAM,GAAN,MAAM,CAAiB;QACvB,eAAU,GAAV,UAAU,CAAQ;IAC1B,CAAC;IACH,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IACD,KAAK,CAAC,GAAG,CAAC,GAAW,EAAE,KAAa,EAAE,UAAU,GAAG,IAAI,CAAC,UAAU;QAChE,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;IACxD,CAAC;IACD,KAAK,CAAC,GAAG,CAAC,GAAW;QACnB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;IACD,KAAK,CAAC,UAAU,CAAC,OAAe;QAC9B,MAAM,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC;YAC1C,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,OAAO,GAAG,EAAE,WAAW,OAAO,EAAE,CAAC;YACjD,CAAC,CAAC,CAAC,WAAW,OAAO,EAAE,EAAE,IAAI,OAAO,GAAG,CAAC,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;QAClC,KAAI,MAAM,CAAC,IAAI,cAAc,EAAC,CAAC;YAC7B,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACvC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACtC,CAAC;YAAC,MAAM,CAAC;gBACP,qCAAqC;YACvC,CAAC;QACH,CAAC;QACD,IAAI,OAAO,CAAC,IAAI,GAAG,CAAC,EAAC,CAAC;YACpB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAED,QAAQ,CAAC,MAAc,EAAE,IAAY;QACnC,OAAO,SAAS,MAAM,IAAI,IAAI,EAAE,CAAC;IACnC,CAAC;CACF"}

package/dist/config/config-schema.d.ts

@@ -0,0 +1,3 @@
+export * from "./schemas/server.schema.js";
+export type ConfigSchemaType = any;
+//# sourceMappingURL=config-schema.d.ts.map

package/dist/config/config-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["../../src/config/config-schema.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,MAAM,MAAM,gBAAgB,GAAG,GAAG,CAAC"}

package/dist/config/config-schema.js

@@ -0,0 +1,2 @@
+export * from "./schemas/server.schema.js";
+//# sourceMappingURL=config-schema.js.map

package/dist/config/config-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.js","sourceRoot":"","sources":["../../src/config/config-schema.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}

package/dist/config/config.d.ts

@@ -0,0 +1,2 @@
+export * from "./config.loader.js";
+//# sourceMappingURL=config.d.ts.map

package/dist/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/config/config.js

@@ -0,0 +1,2 @@
+export * from "./config.loader.js";
+//# sourceMappingURL=config.js.map

package/dist/config/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/config/config.loader.d.ts

@@ -0,0 +1,266 @@
+export declare function parseYAMLConfig(filepath: string): Promise<any>;
+export declare function validateConfig(config: any): Promise<{
+    server: {
+        host: string;
+        port: number;
+        workers: number;
+        trustProxy: boolean;
+        connectTimeoutMs: number;
+        readTimeoutMs: number;
+        compression: boolean;
+        listen: number;
+        upstreams: {
+            id: string;
+            url: string;
+            weight: number;
+            healthPath: string;
+            tls?: {
+                rejectUnauthorized: boolean;
+                ca?: string | undefined;
+            } | undefined;
+            maxConnections?: number | undefined;
+        }[];
+        paths: any[];
+        loadBalancing: {
+            strategy: "round-robin" | "weighted-round-robin" | "least-connections" | "weighted-least-connections" | "least-response-time" | "random" | "ip-hash" | "consistent-hashing" | "power-of-two" | "resource-based" | "sticky-sessions" | "adaptive-wrr";
+            failureThreshold: number;
+            recoveryTimeMs: number;
+            virtualNodes: number;
+            ewmaAlpha: number;
+            stickyCookieName: string;
+            slowStartSeconds: number;
+            retry: {
+                maxAttempts: number;
+                statusCodes: number[];
+            };
+            stickyCookieTtlMs?: number | undefined;
+            stickyMaxAgeSeconds?: number | undefined;
+            maxConnections?: number | undefined;
+        };
+        cache: {
+            enabled: boolean;
+            host: string;
+            port: number;
+            ttlSeconds: number;
+            l1Enabled: boolean;
+            l1MaxSize: number;
+            staleWhileRevalidate: boolean;
+            staleIfError: boolean;
+            key: {
+                ignoreQueryParams: string[];
+                varyHeaders: string[];
+            };
+            debezium: {
+                enabled: boolean;
+                channel: string;
+                mappings: {
+                    table: string;
+                    pathPattern: string;
+                }[];
+            };
+        };
+        resilience: {
+            retry: {
+                enabled: boolean;
+                maxAttempts: number;
+                backoff: "exponential" | "full-jitter" | "equal-jitter" | "decorrelated-jitter";
+                baseDelayMs: number;
+                maxDelayMs: number;
+                budgetPercent: number;
+                retryOn: {
+                    localNodeFailure: boolean;
+                    systemOverload: boolean;
+                };
+            };
+            circuitBreaker: {
+                mode: "classic" | "adaptive";
+                failureThreshold: number;
+                recoveryTimeMs: number;
+                K: number;
+                windowMs: number;
+            };
+            bulkhead: {
+                enabled: boolean;
+                maxConcurrentPerUpstream: number;
+            };
+        };
+        rateLimit: {
+            enabled: boolean;
+            storage: "memory" | "redis" | "hybrid";
+            algorithm: "fixed-window" | "sliding-window-log" | "sliding-window-counter" | "token-bucket" | "leaking-bucket";
+            windowMs: number;
+            maxRequests: number;
+            softLimit: boolean;
+            redis: {
+                host: string;
+                port: number;
+                keyPrefix: string;
+            };
+            headers: boolean;
+            dimensions?: {
+                dimension: "ip" | "route" | "api-key";
+                maxRequests: number;
+                windowMs: number;
+            }[] | undefined;
+        };
+        discovery: {
+            heartbeatTimeoutMs: number;
+            cleanupIntervalMs: number;
+            persistencePath: string;
+        };
+        httpsPort?: number | undefined;
+        sslKeyPath?: string | undefined;
+        sslCertPath?: string | undefined;
+        accessLog?: string | undefined;
+        eventLog?: string | undefined;
+        headers?: any[] | undefined;
+    };
+    tls: {
+        enabled: boolean;
+        cert: string;
+        key: string;
+        redirectHttp: boolean;
+        httpsPort: number;
+    };
+    upstreams: {
+        id: string;
+        url: string;
+        weight: number;
+        healthPath: string;
+        tls?: {
+            rejectUnauthorized: boolean;
+            ca?: string | undefined;
+        } | undefined;
+        maxConnections?: number | undefined;
+    }[];
+    routes: {
+        path: string;
+        upstreams: string[];
+        sticky: boolean;
+        rateLimit?: {
+            windowMs: number;
+            maxRequests: number;
+            algorithm: "fixed-window" | "sliding-window-log" | "sliding-window-counter" | "token-bucket" | "leaking-bucket";
+            storage: "memory" | "redis" | "hybrid";
+        } | undefined;
+        cache?: {
+            enabled: boolean;
+            ttlSeconds?: number | undefined;
+        } | undefined;
+    }[];
+    loadBalancing: {
+        strategy: "round-robin" | "weighted-round-robin" | "least-connections" | "weighted-least-connections" | "least-response-time" | "random" | "ip-hash" | "consistent-hashing" | "power-of-two" | "resource-based" | "sticky-sessions" | "adaptive-wrr";
+        failureThreshold: number;
+        recoveryTimeMs: number;
+        virtualNodes: number;
+        ewmaAlpha: number;
+        stickyCookieName: string;
+        slowStartSeconds: number;
+        retry: {
+            maxAttempts: number;
+            statusCodes: number[];
+        };
+        stickyCookieTtlMs?: number | undefined;
+        stickyMaxAgeSeconds?: number | undefined;
+        maxConnections?: number | undefined;
+    };
+    resilience: {
+        retry: {
+            enabled: boolean;
+            maxAttempts: number;
+            backoff: "exponential" | "full-jitter" | "equal-jitter" | "decorrelated-jitter";
+            baseDelayMs: number;
+            maxDelayMs: number;
+            budgetPercent: number;
+            retryOn: {
+                localNodeFailure: boolean;
+                systemOverload: boolean;
+            };
+        };
+        circuitBreaker: {
+            mode: "classic" | "adaptive";
+            failureThreshold: number;
+            recoveryTimeMs: number;
+            K: number;
+            windowMs: number;
+        };
+        bulkhead: {
+            enabled: boolean;
+            maxConcurrentPerUpstream: number;
+        };
+    };
+    rateLimit: {
+        enabled: boolean;
+        storage: "memory" | "redis" | "hybrid";
+        algorithm: "fixed-window" | "sliding-window-log" | "sliding-window-counter" | "token-bucket" | "leaking-bucket";
+        windowMs: number;
+        maxRequests: number;
+        softLimit: boolean;
+        redis: {
+            host: string;
+            port: number;
+            keyPrefix: string;
+        };
+        headers: boolean;
+        dimensions?: {
+            dimension: "ip" | "route" | "api-key";
+            maxRequests: number;
+            windowMs: number;
+        }[] | undefined;
+    };
+    cache: {
+        enabled: boolean;
+        host: string;
+        port: number;
+        ttlSeconds: number;
+        l1Enabled: boolean;
+        l1MaxSize: number;
+        staleWhileRevalidate: boolean;
+        staleIfError: boolean;
+        key: {
+            ignoreQueryParams: string[];
+            varyHeaders: string[];
+        };
+        debezium: {
+            enabled: boolean;
+            channel: string;
+            mappings: {
+                table: string;
+                pathPattern: string;
+            }[];
+        };
+    };
+    discovery: {
+        heartbeatTimeoutMs: number;
+        cleanupIntervalMs: number;
+        persistencePath: string;
+    };
+    observability: {
+        logging: {
+            level: "debug" | "info" | "warn" | "error";
+            accessLog: string | boolean;
+        };
+        metrics: {
+            enabled: boolean;
+            path: string;
+            histograms: boolean;
+            perTenantMetrics: boolean;
+        };
+        tracing: {
+            enabled: boolean;
+            endpoint: string;
+        };
+        tenantDelivery?: {
+            mode: "webhook" | "none";
+            exportEndpoints: {
+                tenantId: string;
+                destination: string;
+            }[];
+        } | undefined;
+    };
+    admin: {
+        enabled: boolean;
+        pathPrefix: string;
+    };
+}>;
+//# sourceMappingURL=config.loader.d.ts.map

package/dist/config/config.loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.loader.d.ts","sourceRoot":"","sources":["../../src/config/config.loader.ts"],"names":[],"mappings":"AAkIA,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,gBAmErD;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAO/C"}

package/dist/config/config.loader.js

@@ -0,0 +1,204 @@
+import { promises as fs } from "fs";
+import { parse } from "yaml";
+import { rootConfigSchema } from "./schemas/server.schema.js";
+import path from "path";
+import { logger } from "../observability/logger/logger.js";
+function mapBackwardCompatibleKeys(configParsed) {
+    if (!configParsed)
+        return {};
+    if (!configParsed.server)
+        configParsed.server = {};
+    if (configParsed.server.listen !== undefined && configParsed.server.port === undefined) {
+        configParsed.server.port = configParsed.server.listen;
+    }
+    if (!configParsed.tls) {
+        configParsed.tls = {};
+    }
+    if (configParsed.server.sslCertPath !== undefined && configParsed.tls.cert === undefined) {
+        configParsed.tls.cert = configParsed.server.sslCertPath;
+        configParsed.tls.enabled = true;
+    }
+    if (configParsed.server.sslKeyPath !== undefined && configParsed.tls.key === undefined) {
+        configParsed.tls.key = configParsed.server.sslKeyPath;
+        configParsed.tls.enabled = true;
+    }
+    if (configParsed.server.httpsPort !== undefined && configParsed.tls.httpsPort === undefined) {
+        configParsed.tls.httpsPort = configParsed.server.httpsPort;
+    }
+    const effectiveUpstreams = configParsed.upstreams || configParsed.server?.upstreams;
+    if (effectiveUpstreams) {
+        configParsed.upstreams = effectiveUpstreams;
+        configParsed.server.upstreams = effectiveUpstreams;
+    }
+    if (configParsed.server.paths !== undefined && configParsed.routes === undefined) {
+        configParsed.routes = configParsed.server.paths.map((p) => {
+            const upstreams = p.upstreams || (p.upstream ? (Array.isArray(p.upstream) ? p.upstream : [p.upstream]) : []);
+            return {
+                path: p.path,
+                upstreams,
+                rateLimit: p.rateLimit,
+                sticky: p.sticky,
+                cache: p.cache,
+            };
+        });
+    }
+    else if (configParsed.routes) {
+        configParsed.routes = configParsed.routes.map((p) => {
+            const upstreams = p.upstreams || (p.upstream ? (Array.isArray(p.upstream) ? p.upstream : [p.upstream]) : []);
+            return {
+                ...p,
+                upstreams,
+            };
+        });
+        configParsed.server.paths = configParsed.routes.map((r) => ({
+            path: r.path,
+            upstream: r.upstreams,
+            rateLimit: r.rateLimit,
+            sticky: r.sticky,
+            cache: r.cache,
+        }));
+    }
+    const sections = ["loadBalancing", "cache", "resilience", "rateLimit", "discovery"];
+    for (const section of sections) {
+        if (configParsed.server[section] !== undefined && configParsed[section] === undefined) {
+            configParsed[section] = configParsed.server[section];
+        }
+    }
+    if (!configParsed.observability) {
+        configParsed.observability = {};
+    }
+    if (!configParsed.observability.logging) {
+        configParsed.observability.logging = {};
+    }
+    if (configParsed.server.accessLog !== undefined && configParsed.observability.logging.accessLog === undefined) {
+        configParsed.observability.logging.accessLog = configParsed.server.accessLog;
+    }
+    if (configParsed.loadBalancing?.retry) {
+        if (!configParsed.resilience)
+            configParsed.resilience = {};
+        if (!configParsed.resilience.retry)
+            configParsed.resilience.retry = {};
+        configParsed.resilience.retry = {
+            ...configParsed.resilience.retry,
+            ...configParsed.loadBalancing.retry,
+        };
+    }
+    if (configParsed.tenant_delivery !== undefined && configParsed.observability?.tenantDelivery === undefined) {
+        if (!configParsed.observability)
+            configParsed.observability = {};
+        configParsed.observability.tenantDelivery = configParsed.tenant_delivery;
+    }
+    return configParsed;
+}
+function applyEnvironmentOverrides(configParsed) {
+    if (!configParsed.server)
+        configParsed.server = {};
+    if (!configParsed.tls)
+        configParsed.tls = {};
+    if (!configParsed.cache)
+        configParsed.cache = {};
+    if (!configParsed.rateLimit)
+        configParsed.rateLimit = {};
+    if (!configParsed.rateLimit.redis)
+        configParsed.rateLimit.redis = {};
+    if (!configParsed.observability)
+        configParsed.observability = {};
+    if (!configParsed.observability.logging)
+        configParsed.observability.logging = {};
+    if (process.env.PORT) {
+        configParsed.server.port = parseInt(process.env.PORT, 10);
+    }
+    if (process.env.HOST) {
+        configParsed.server.host = process.env.HOST;
+    }
+    if (process.env.WORKERS) {
+        configParsed.server.workers = parseInt(process.env.WORKERS, 10);
+    }
+    if (process.env.REDIS_HOST) {
+        configParsed.cache.host = process.env.REDIS_HOST;
+        configParsed.rateLimit.redis.host = process.env.REDIS_HOST;
+    }
+    if (process.env.REDIS_PORT) {
+        const rPort = parseInt(process.env.REDIS_PORT, 10);
+        configParsed.cache.port = rPort;
+        configParsed.rateLimit.redis.port = rPort;
+    }
+    if (process.env.LOG_LEVEL) {
+        configParsed.observability.logging.level = process.env.LOG_LEVEL;
+    }
+    return configParsed;
+}
+export async function parseYAMLConfig(filepath) {
+    const configFileContent = await fs.readFile(filepath, "utf-8");
+    let configParsed = parse(configFileContent) || {};
+    const configDir = path.join(path.dirname(filepath), "config.d");
+    let dirExists = false;
+    try {
+        const stat = await fs.stat(configDir);
+        dirExists = stat.isDirectory();
+    }
+    catch {
+        dirExists = false;
+    }
+    if (dirExists) {
+        try {
+            const files = await fs.readdir(configDir);
+            const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+            const parsePromises = yamlFiles.map(async (file) => {
+                const extraFilePath = path.join(configDir, file);
+                try {
+                    const extraContent = await fs.readFile(extraFilePath, "utf-8");
+                    return parse(extraContent);
+                }
+                catch (err) {
+                    logger.error("Config", `Skipped broken file ${file}: ${err.message}`, { file });
+                    return null;
+                }
+            });
+            const parsedFilesResults = await Promise.all(parsePromises);
+            for (const extraParsed of parsedFilesResults) {
+                if (extraParsed) {
+                    // Merge upstreams
+                    const extraUps = extraParsed.upstreams || extraParsed.server?.upstreams;
+                    if (extraUps && Array.isArray(extraUps)) {
+                        if (!configParsed.upstreams)
+                            configParsed.upstreams = [];
+                        configParsed.upstreams = [...configParsed.upstreams, ...extraUps];
+                    }
+                    // Merge routes / paths
+                    const extraRoutes = extraParsed.routes || extraParsed.server?.paths;
+                    if (extraRoutes && Array.isArray(extraRoutes)) {
+                        if (!configParsed.routes)
+                            configParsed.routes = [];
+                        configParsed.routes = [...configParsed.routes, ...extraRoutes];
+                    }
+                    // Merge headers
+                    const extraHeaders = extraParsed.server?.headers;
+                    if (extraHeaders && Array.isArray(extraHeaders)) {
+                        if (!configParsed.server)
+                            configParsed.server = {};
+                        if (!configParsed.server.headers)
+                            configParsed.server.headers = [];
+                        configParsed.server.headers = [...configParsed.server.headers, ...extraHeaders];
+                    }
+                }
+            }
+        }
+        catch (dirErr) {
+            logger.error("Config", `Error reading config.d directory: ${dirErr.message}`);
+        }
+    }
+    configParsed = mapBackwardCompatibleKeys(configParsed);
+    configParsed = applyEnvironmentOverrides(configParsed);
+    return configParsed;
+}
+export async function validateConfig(config) {
+    try {
+        return await rootConfigSchema.parseAsync(config);
+    }
+    catch (err) {
+        console.error("Configuration validation failed:\n", err.message || err);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=config.loader.js.map