veryfront 0.1.1067 → 0.1.1069

package/esm/src/proxy/handler.js

@@ -26,6 +26,7 @@ export const INTERNAL_PROXY_HEADERS = [
 ];
 const DEFAULT_PROXY_ROUTING_CACHE_TTL_MS = 60_000;
 const DEFAULT_PROXY_ROUTING_CACHE_MAX_ENTRIES = 1_000;
+const MAX_ROUTING_LOOKUP_INVALIDATION_RETRIES = 2;
 function readNonNegativeIntegerEnv(name, fallback) {
     const raw = getEnv(name);
     if (!raw)
@@ -46,6 +47,12 @@ class ProxyLookupAuthError extends Error {
         this.name = "ProxyLookupAuthError";
     }
 }
+class ProxyRoutingInvalidationRaceError extends Error {
+    constructor() {
+        super("Project routing changed during request; retry");
+        this.name = "ProxyRoutingInvalidationRaceError";
+    }
+}
 function isProxyLookupAuthError(error) {
     return error instanceof ProxyLookupAuthError;
 }
@@ -225,6 +232,11 @@ export function createProxyHandler(options) {
     const routingCacheMaxEntries = readNonNegativeIntegerEnv("VERYFRONT_PROXY_ROUTING_CACHE_MAX_ENTRIES", DEFAULT_PROXY_ROUTING_CACHE_MAX_ENTRIES);
     const routingLookupCache = new Map();
     const routingLookupInflight = new Map();
+    const projectInvalidationGenerations = new Map();
+    const lookupKeyInvalidationGenerations = new Map();
+    const activeRoutingLookupGenerations = new Map();
+    const maxTrackedInvalidationGenerations = Math.max(routingCacheMaxEntries, DEFAULT_PROXY_ROUTING_CACHE_MAX_ENTRIES);
+    let routingLookupGeneration = 0;
     async function resolveProjectLookup(lookupKey, token, timing) {
         return await profileProxyServerTimingPhase(timing ?? { enabled: false, startedAt: 0, phases: new Map() }, "proxy.project_lookup", () => lookupProjectByDomain(lookupKey, config.apiBaseUrl, token, logger));
     }
@@ -261,6 +273,71 @@ export function createProxyHandler(options) {
             expiresAt: Date.now() + routingCacheTtlMs,
         });
     }
+    function pruneInvalidationGenerations(generations) {
+        const oldestActiveGeneration = activeRoutingLookupGenerations.size > 0
+            ? Math.min(...activeRoutingLookupGenerations.keys())
+            : Number.POSITIVE_INFINITY;
+        while (generations.size > maxTrackedInvalidationGenerations) {
+            const oldestEntry = generations.entries().next().value;
+            if (!oldestEntry || oldestEntry[1] > oldestActiveGeneration)
+                break;
+            generations.delete(oldestEntry[0]);
+        }
+    }
+    function rememberInvalidationGeneration(generations, key, generation) {
+        generations.delete(key);
+        generations.set(key, generation);
+        pruneInvalidationGenerations(generations);
+    }
+    function beginRoutingLookup(generation) {
+        activeRoutingLookupGenerations.set(generation, (activeRoutingLookupGenerations.get(generation) ?? 0) + 1);
+    }
+    function endRoutingLookup(generation) {
+        const activeCount = activeRoutingLookupGenerations.get(generation) ?? 0;
+        if (activeCount <= 1)
+            activeRoutingLookupGenerations.delete(generation);
+        else
+            activeRoutingLookupGenerations.set(generation, activeCount - 1);
+        pruneInvalidationGenerations(projectInvalidationGenerations);
+        pruneInvalidationGenerations(lookupKeyInvalidationGenerations);
+    }
+    function wasRoutingLookupInvalidated(cacheKey, result, startedAtGeneration) {
+        const keyGeneration = lookupKeyInvalidationGenerations.get(cacheKey) ?? 0;
+        if (keyGeneration > startedAtGeneration)
+            return true;
+        if (!result)
+            return false;
+        return (projectInvalidationGenerations.get(result.id) ?? 0) > startedAtGeneration;
+    }
+    function invalidateRoutingLookup(input) {
+        const generation = ++routingLookupGeneration;
+        rememberInvalidationGeneration(projectInvalidationGenerations, input.projectId, generation);
+        const normalizedProjectSlug = input.projectSlug
+            ? normalizeProjectLookupKey(input.projectSlug)
+            : undefined;
+        if (normalizedProjectSlug) {
+            rememberInvalidationGeneration(lookupKeyInvalidationGenerations, normalizedProjectSlug, generation);
+        }
+        let evictedEntries = 0;
+        for (const [cacheKey, entry] of routingLookupCache) {
+            if (entry.value.id !== input.projectId && cacheKey !== normalizedProjectSlug)
+                continue;
+            routingLookupCache.delete(cacheKey);
+            rememberInvalidationGeneration(lookupKeyInvalidationGenerations, cacheKey, generation);
+            evictedEntries++;
+        }
+        logger?.info("Proxy routing metadata invalidated after deployment activation", {
+            projectId: input.projectId,
+            projectSlug: input.projectSlug,
+            deploymentId: input.deploymentId,
+            environmentId: input.environmentId,
+            environmentName: input.environmentName,
+            releaseId: input.releaseId,
+            generation,
+            evictedEntries,
+        });
+        return { evictedEntries, generation };
+    }
     async function resolveProjectRoutingLookup(lookupKey, token, timing) {
         const cacheKey = normalizeProjectLookupKey(lookupKey);
         return await profileProxyServerTimingPhase(timing ?? { enabled: false, startedAt: 0, phases: new Map() }, "proxy.routing_lookup", async () => {
@@ -270,27 +347,89 @@ export function createProxyHandler(options) {
                 return cached;
             }
             const existingLookup = routingLookupInflight.get(cacheKey);
-            if (existingLookup) {
+            if (existingLookup?.generation === routingLookupGeneration) {
                 logger?.debug("Proxy routing metadata lookup joined in-flight request", { lookupKey });
-                return await existingLookup;
+                return await existingLookup.promise;
             }
-            const lookupPromise = lookupProjectRoutingMetadata(lookupKey, config.apiBaseUrl, token, logger)
-                .then((result) => {
-                if (result) {
-                    setCachedRoutingLookup(cacheKey, result);
+            const lookupPromise = (async () => {
+                for (let attempt = 0; attempt <= MAX_ROUTING_LOOKUP_INVALIDATION_RETRIES; attempt++) {
+                    const startedAtGeneration = routingLookupGeneration;
+                    beginRoutingLookup(startedAtGeneration);
+                    try {
+                        const result = await lookupProjectRoutingMetadata(lookupKey, config.apiBaseUrl, token, logger);
+                        if (!wasRoutingLookupInvalidated(cacheKey, result, startedAtGeneration)) {
+                            if (result)
+                                setCachedRoutingLookup(cacheKey, result);
+                            return result;
+                        }
+                        logger?.info("Retrying proxy routing metadata lookup after invalidation race", {
+                            lookupKey,
+                            attempt: attempt + 1,
+                            generation: routingLookupGeneration,
+                        });
+                        if (attempt === MAX_ROUTING_LOOKUP_INVALIDATION_RETRIES) {
+                            logger?.warn("Proxy routing metadata changed repeatedly during lookup; failing request closed", {
+                                lookupKey,
+                                attempts: attempt + 1,
+                            });
+                            throw new ProxyRoutingInvalidationRaceError();
+                        }
+                    }
+                    finally {
+                        endRoutingLookup(startedAtGeneration);
+                    }
                 }
-                return result;
-            })
-                .finally(() => {
-                routingLookupInflight.delete(cacheKey);
-            });
-            routingLookupInflight.set(cacheKey, lookupPromise);
-            return await lookupPromise;
+                return null;
+            })();
+            const inflightEntry = {
+                generation: routingLookupGeneration,
+                promise: lookupPromise,
+            };
+            routingLookupInflight.set(cacheKey, inflightEntry);
+            try {
+                return await lookupPromise;
+            }
+            finally {
+                if (routingLookupInflight.get(cacheKey) === inflightEntry) {
+                    routingLookupInflight.delete(cacheKey);
+                }
+            }
         });
     }
     async function resolveProjectAccessLookup(lookupKey, token, includeUsers, timing) {
         return await profileProxyServerTimingPhase(timing ?? { enabled: false, startedAt: 0, phases: new Map() }, "proxy.access_lookup", () => lookupProjectAccessMetadata(lookupKey, config.apiBaseUrl, token, includeUsers, logger));
     }
+    async function invalidateAndConfirmRoutingLookup(input) {
+        invalidateRoutingLookup(input);
+        const scope = getScope(input.environmentName.toLowerCase());
+        const resolveWithToken = async (token) => {
+            const result = await resolveProjectRoutingLookup(input.projectSlug, token);
+            const environment = result?.environments?.find((candidate) => candidate.id === input.environmentId);
+            if (result?.id !== input.projectId ||
+                environment?.active_release_id !== input.releaseId) {
+                throw new Error(`Proxy routing metadata did not converge for project ${input.projectId} environment ${input.environmentId}`);
+            }
+        };
+        let token = await tokenManager.getToken(scope, input.projectSlug);
+        try {
+            await resolveWithToken(token);
+        }
+        catch (error) {
+            if (!isProxyLookupAuthError(error))
+                throw error;
+            await tokenManager.invalidateToken(scope, input.projectSlug);
+            token = await tokenManager.getToken(scope, input.projectSlug);
+            await resolveWithToken(token);
+        }
+        logger?.info("Proxy routing metadata converged after deployment activation", {
+            projectId: input.projectId,
+            projectSlug: input.projectSlug,
+            deploymentId: input.deploymentId,
+            environmentId: input.environmentId,
+            environmentName: input.environmentName,
+            releaseId: input.releaseId,
+        });
+    }
     function validateConfig() {
         const missing = [];
         if (!config.apiClientId)
@@ -410,6 +549,9 @@ export function createProxyHandler(options) {
                 return await resolveWithCurrentToken();
             }
             catch (error) {
+                if (error instanceof ProxyRoutingInvalidationRaceError) {
+                    return { error: { status: 503, message: error.message } };
+                }
                 if (!isProxyLookupAuthError(error))
                     throw error;
                 const projectKey = tokenIdentity.projectSlug ?? tokenIdentity.customDomain;
@@ -444,6 +586,9 @@ export function createProxyHandler(options) {
                     return await resolveWithCurrentToken();
                 }
                 catch (retryError) {
+                    if (retryError instanceof ProxyRoutingInvalidationRaceError) {
+                        return { error: { status: 503, message: retryError.message } };
+                    }
                     if (!isProxyLookupAuthError(retryError))
                         throw retryError;
                     logger?.error("Proxy API token rejected after refresh", retryError, {
@@ -689,6 +834,8 @@ export function createProxyHandler(options) {
         getStats,
         close,
         validateConfig,
+        invalidateRoutingLookup,
+        invalidateAndConfirmRoutingLookup,
         localProjects,
     };
 }

package/esm/src/proxy/main.js

@@ -15,6 +15,8 @@
  * - LOCAL_PROJECTS: JSON map of slug → filesystem path (for dev)
  * - CACHE_TYPE: "memory" (default) or "redis"
  * - REDIS_URL: Redis connection URL (required if CACHE_TYPE=redis)
+ * - VERYFRONT_PROXY_EXPECTED_REPLICAS: Minimum proxy replicas required to acknowledge routing changes
+ * - VERYFRONT_PROXY_ROUTING_INVALIDATION_SECRET: HMAC secret for Redis routing events and acknowledgements
  * - VERYFRONT_API_INTERNAL_URL: API URL for internal endpoints (falls back to VERYFRONT_PROXY_API_BASE_URL)
  * - VERYFRONT_API_INTERNAL_USER: Basic auth user for internal API
  * - VERYFRONT_API_INTERNAL_PASS: Basic auth pass for internal API
@@ -42,6 +44,8 @@ import { createUpstreamFailureResponse, createUpstreamTimeoutResponse, UPSTREAM_
 import { createProxyServerTiming, markProxyServerTimingPhase, profileProxyServerTimingPhase, withProxyServerTimingHeader, } from "./server-timing.js";
 import { removeStickyCookieFromPublicCacheableResponse } from "./response-headers.js";
 import { closeProxyServerWithin, createProxyDrainingResponse, parseProxyDrainTimeoutMs, ProxyRequestDrainTracker, } from "./request-drain.js";
+import { handleProxyRoutingInvalidationRequest, PROXY_ROUTING_INVALIDATION_PATH, } from "./routing-invalidation.js";
+import { startProxyRoutingInvalidationBus } from "./routing-invalidation-redis.js";
 function getLocalProjects() {
     const raw = getEnv("LOCAL_PROJECTS");
     return raw ? JSON.parse(raw) : {};
@@ -98,6 +102,17 @@ const DEFAULT_SERVER_RETRY_DELAY_MS = 100;
 const VERYFRONT_SERVER_RETRY_COUNT = parseInt(getEnv("VERYFRONT_SERVER_RETRY_COUNT") || String(DEFAULT_SERVER_RETRY_COUNT));
 const VERYFRONT_SERVER_RETRY_DELAY_MS = parseInt(getEnv("VERYFRONT_SERVER_RETRY_DELAY_MS") || String(DEFAULT_SERVER_RETRY_DELAY_MS));
 const SHUTDOWN_DRAIN_TIMEOUT_MS = parseProxyDrainTimeoutMs(getEnv("SHUTDOWN_DRAIN_TIMEOUT_MS"), DEFAULT_SHUTDOWN_DRAIN_TIMEOUT_MS);
+const routingInvalidationSecret = getEnv("VERYFRONT_PROXY_ROUTING_INVALIDATION_SECRET") ?? "";
+const routingInvalidationSecretBytes = new TextEncoder().encode(routingInvalidationSecret).byteLength;
+const expectedReplicasRaw = getEnv("VERYFRONT_PROXY_EXPECTED_REPLICAS");
+const expectedReplicas = Number(expectedReplicasRaw);
+const hasValidExpectedReplicas = Number.isInteger(expectedReplicas) && expectedReplicas > 0;
+if (isProduction() && !hasValidExpectedReplicas) {
+    throw new Error("VERYFRONT_PROXY_EXPECTED_REPLICAS must be a positive integer in production");
+}
+if (isProduction() && routingInvalidationSecretBytes < 32) {
+    throw new Error("VERYFRONT_PROXY_ROUTING_INVALIDATION_SECRET must contain at least 32 bytes in production");
+}
 const proxyRequestDrainTracker = new ProxyRequestDrainTracker();
 let shuttingDown = false;
 const { createAuthProvider } = await importFirstPartyExtensionModule("ext-auth-jwt", "@veryfront/ext-auth-jwt").catch((error) => {
@@ -106,16 +121,32 @@ const { createAuthProvider } = await importFirstPartyExtensionModule("ext-auth-j
 register("AuthProvider", createAuthProvider({}));
 // Initialize cache and proxy handler
 const cache = await createCacheFromEnv();
+const routingInvalidationLogger = {
+    debug: (msg, extra) => proxyLogger.debug(msg, extra),
+    info: (msg, extra) => proxyLogger.info(msg, extra),
+    warn: (msg, extra) => proxyLogger.warn(msg, extra),
+    error: (msg, error, extra) => proxyLogger.error(msg, extra ?? {}, error),
+};
 const proxyHandler = createProxyHandler({
     config,
     cache,
-    logger: {
-        debug: (msg, extra) => proxyLogger.debug(msg, extra),
-        info: (msg, extra) => proxyLogger.info(msg, extra),
-        warn: (msg, extra) => proxyLogger.warn(msg, extra),
-        error: (msg, error, extra) => proxyLogger.error(msg, extra ?? {}, error),
-    },
+    logger: routingInvalidationLogger,
+});
+const routingInvalidationBus = await startProxyRoutingInvalidationBus({
+    expectedReplicas: hasValidExpectedReplicas ? expectedReplicas : undefined,
+    integritySecret: routingInvalidationSecret,
+    logger: routingInvalidationLogger,
+    onInvalidate: proxyHandler.invalidateAndConfirmRoutingLookup,
+}).catch((error) => {
+    if (isProduction()) {
+        throw new Error("Proxy routing invalidation bus failed to start", { cause: error });
+    }
+    proxyLogger.error("Proxy routing invalidation bus failed; TTL recovery remains active", {}, error instanceof Error ? error : new Error(String(error)));
+    return null;
 });
+if (isProduction() && !routingInvalidationBus) {
+    throw new Error("Proxy routing invalidation bus requires REDIS_URL and a valid VERYFRONT_PROXY_ROUTING_INVALIDATION_SECRET in production");
+}
 // Validate configuration on startup
 const missingCredentials = proxyHandler.validateConfig();
 if (missingCredentials.length > 0) {
@@ -499,6 +530,11 @@ async function router(req) {
         if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
             response = await handleWebSocketUpgrade(req, url);
         }
+        else if (url.pathname === PROXY_ROUTING_INVALIDATION_PATH) {
+            response = await handleProxyRoutingInvalidationRequest(req, {
+                publisher: routingInvalidationBus,
+            });
+        }
         else if (url.pathname === "/_proxy/stats") {
             response = Object.keys(proxyHandler.localProjects).length === 0
                 ? new Response("Forbidden", { status: 403 })
@@ -533,6 +569,8 @@ async function shutdown(signal) {
         drainTimeoutMs: SHUTDOWN_DRAIN_TIMEOUT_MS,
     });
     try {
+        // New requests receive the draining response after shuttingDown is set.
+        // Keep this replica subscribed while already-started responses finish.
         const drained = await proxyRequestDrainTracker.waitForDrain(SHUTDOWN_DRAIN_TIMEOUT_MS);
         if (!drained) {
             const now = performance.now();
@@ -545,6 +583,7 @@ async function shutdown(signal) {
                 })),
             });
         }
+        await routingInvalidationBus?.close();
         const closed = await closeProxyServerWithin(() => server.close(), PROXY_SERVER_CLOSE_TIMEOUT_MS);
         if (!closed) {
             proxyLogger.warn("Proxy server close timed out; process exit will close remaining connections", {

package/esm/src/proxy/retry.d.ts

@@ -6,6 +6,7 @@
  * These occur when renderer pods are being recycled or temporarily unavailable.
  */
 export declare function isRetryableConnectionError(error: unknown): boolean;
+export declare function isConnectionRefusedError(error: unknown): boolean;
 /**
  * Decide how many times the proxy can safely retry an upstream request.
  *

package/esm/src/proxy/retry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/src/proxy/retry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAUlE;AAwCD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,oBAAoB,EAAE,MAAM,GAC3B,MAAM,CAUR;AAED,0EAA0E;AAC1E,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,OAAO,CAQT;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,GACjB,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAc1C"}
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/src/proxy/retry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAyCH;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAWlE;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQhE;AAkCD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,oBAAoB,EAAE,MAAM,GAC3B,MAAM,CAUR;AAED,0EAA0E;AAC1E,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,OAAO,CAQT;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,GACjB,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAc1C"}

package/esm/src/proxy/retry.js

@@ -3,26 +3,43 @@
  */
 import { DEFAULT_MAX_BODY_SIZE_BYTES } from "../utils/constants/index.js";
 const CONTROL_PLANE_RUN_STREAM_PATH = /^\/api\/control-plane\/runs\/[^/]+\/stream$/;
+const MAX_ERROR_CAUSE_DEPTH = 8;
+const RETRYABLE_CONNECTION_CODES = new Set(["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT"]);
+const CONNECTION_REFUSED_CODES = new Set(["ECONNREFUSED"]);
+function errorChainMatches(error, predicate) {
+    if (!(error instanceof Error))
+        return false;
+    const seen = new Set();
+    let current = error;
+    for (let depth = 0; depth < MAX_ERROR_CAUSE_DEPTH; depth++) {
+        if (typeof current !== "object" || current === null || seen.has(current))
+            return false;
+        seen.add(current);
+        const details = current;
+        const message = typeof details.message === "string" ? details.message.toLowerCase() : "";
+        const code = typeof details.code === "string" ? details.code.toUpperCase() : "";
+        if (predicate(message, code))
+            return true;
+        current = details.cause;
+    }
+    return false;
+}
 /**
  * Check if a fetch error is a transient connection error worth retrying.
  * These occur when renderer pods are being recycled or temporarily unavailable.
  */
 export function isRetryableConnectionError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const msg = error.message.toLowerCase();
-    return (msg.includes("connection reset") ||
-        msg.includes("connection closed") ||
-        msg.includes("connection refused") ||
-        msg.includes("os error 104") || // ECONNRESET
-        msg.includes("os error 111") // ECONNREFUSED
-    );
+    return errorChainMatches(error, (message, code) => RETRYABLE_CONNECTION_CODES.has(code) ||
+        message.includes("connection reset") ||
+        message.includes("connection closed") ||
+        message.includes("connection refused") ||
+        message.includes("os error 104") || // ECONNRESET
+        message.includes("os error 111"));
 }
-function isConnectionRefusedError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const message = error.message.toLowerCase();
-    return message.includes("connection refused") || message.includes("os error 111");
+export function isConnectionRefusedError(error) {
+    return errorChainMatches(error, (message, code) => CONNECTION_REFUSED_CODES.has(code) ||
+        message.includes("connection refused") ||
+        message.includes("os error 111"));
 }
 function isIdempotentMethod(method) {
     return method === "GET" || method === "HEAD" || method === "OPTIONS";

package/esm/src/proxy/routing-invalidation-redis.d.ts

@@ -0,0 +1,33 @@
+import type { ProxyRoutingInvalidationEvent, ProxyRoutingInvalidationPublisher } from "./routing-invalidation.js";
+type RedisListener = (message: string, channel: string) => void;
+export interface RoutingInvalidationRedisClient {
+    connect(): Promise<void>;
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(channel: string, listener: RedisListener): Promise<number>;
+    unsubscribe(channel: string): Promise<number>;
+    close(): Promise<void>;
+    destroy(): void;
+    on?(event: "error", listener: (error: unknown) => void): unknown;
+}
+interface RoutingInvalidationLogger {
+    info(message: string, extra?: Record<string, unknown>): void;
+    warn(message: string, extra?: Record<string, unknown>): void;
+    error(message: string, error?: Error, extra?: Record<string, unknown>): void;
+}
+export interface ProxyRoutingInvalidationBus extends ProxyRoutingInvalidationPublisher {
+    close(): Promise<void>;
+}
+interface StartProxyRoutingInvalidationBusOptions {
+    acknowledgementTimeoutMs?: number;
+    createClient?: (redisUrl: string) => RoutingInvalidationRedisClient | Promise<RoutingInvalidationRedisClient>;
+    expectedReplicas?: number;
+    now?: () => number;
+    logger?: RoutingInvalidationLogger;
+    onInvalidate: (event: ProxyRoutingInvalidationEvent) => unknown | Promise<unknown>;
+    integritySecret?: string;
+    redisUrl?: string;
+    replicaId?: string;
+}
+export declare function startProxyRoutingInvalidationBus(options: StartProxyRoutingInvalidationBusOptions): Promise<ProxyRoutingInvalidationBus | null>;
+export {};
+//# sourceMappingURL=routing-invalidation-redis.d.ts.map

package/esm/src/proxy/routing-invalidation-redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-invalidation-redis.d.ts","sourceRoot":"","sources":["../../../src/src/proxy/routing-invalidation-redis.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,6BAA6B,EAC7B,iCAAiC,EAElC,MAAM,2BAA2B,CAAC;AAgBnC,KAAK,aAAa,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAGhE,MAAM,WAAW,8BAA8B;IAC7C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3D,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrE,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,OAAO,IAAI,IAAI,CAAC;IAChB,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC;CAClE;AAED,UAAU,yBAAyB;IACjC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC7D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC7D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9E;AAED,MAAM,WAAW,2BAA4B,SAAQ,iCAAiC;IACpF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,UAAU,uCAAuC;IAC/C,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,YAAY,CAAC,EAAE,CACb,QAAQ,EAAE,MAAM,KACb,8BAA8B,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAAC;IAC9E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,yBAAyB,CAAC;IACnC,YAAY,EAAE,CAAC,KAAK,EAAE,6BAA6B,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAmPD,wBAAsB,gCAAgC,CACpD,OAAO,EAAE,uCAAuC,GAC/C,OAAO,CAAC,2BAA2B,GAAG,IAAI,CAAC,CAgP7C"}