fix(auth/redis): fail-fast circuit breaker + offline queue off

OAuth was hanging 18-23s per request when REDIS_URL was set but Redis
wasn't actually running. ioredis was buffering commands and retrying
on every get/set, multiplied by the number of secondaryStorage calls
Better Auth makes per request.

- enableOfflineQueue: false — commands fail instantly, no buffering
- connectTimeout: 500ms
- maxRetriesPerRequest: 1
- process-local circuit breaker — once 'error' fires, get/set/delete
  short-circuit to null/no-op until the 'ready' event resets it
- single connection-error log per outage; 'reconnected' log on
  recovery

NOTE: when REDIS_URL is set but unreachable, Better Auth still uses
the in-memory state store but secondaryStorage calls return null —
which means OAuth state, magic-link tokens etc. cannot round-trip.
For local dev: run `pnpm redis:start` OR unset REDIS_URL in .env.

Author: f-amine

packages/auth/src/lib/redis.ts

@@ -4,12 +4,19 @@
 // in-memory store (fine for dev / single-instance). In production, set
 // REDIS_URL to enable the shared rate-limit window across replicas and
 // survive container restarts.
+//
+// Fail-fast policy: when Redis is unreachable we trip a process-local
+// circuit breaker so subsequent get/set/delete calls return immediately
+// (null / no-op) instead of blocking the request thread on retries.
+// The breaker resets on `ready` so a recovered Redis is picked up
+// without a server restart.
 
 import "server-only";
 import { env } from "@starter-saas/env/server";
 import Redis from "ioredis";
 
 let client: Redis | null = null;
+let breakerOpen = false;
 let warned = false;
 
 function getRedis(): Redis | null {
@@ -21,18 +28,41 @@ function getRedis(): Redis | null {
 	}
 	client = new Redis(env.REDIS_URL, {
 		password: env.REDIS_PASSWORD,
-		// Connection retries are handled by ioredis defaults. We don't want
-		// auth requests to hang for minutes on a downed Redis — fail fast
-		// and fall back to the next layer.
-		maxRetriesPerRequest: 2,
+		// Aggressive fail-fast settings — auth requests must never block on a
+		// downed Redis. Better Auth's secondaryStorage is best-effort; when
+		// it errors we fall back to the in-memory layer.
+		maxRetriesPerRequest: 1,
 		enableReadyCheck: true,
 		lazyConnect: false,
+		connectTimeout: 500,
+		// Reject queued commands immediately instead of waiting for a
+		// connection that may never come up. Without this ioredis buffers
+		// commands and resolves them after `maxRetriesPerRequest` * backoff.
+		enableOfflineQueue: false,
+		retryStrategy(times) {
+			// Back off exponentially up to 30s. Don't return `null` (would
+			// kill the client) — we want the breaker to flip closed if Redis
+			// recovers.
+			return Math.min(times * 1000, 30_000);
+		},
 	});
 	client.on("error", (err) => {
+		breakerOpen = true;
 		if (!warned) {
 			warned = true;
-			console.error("[auth/redis] connection error:", err.message);
+			console.error(
+				"[auth/redis] connection error:",
+				err.message,
+				"— falling back to in-memory (no further errors will be logged until reconnect)",
+			);
+		}
+	});
+	client.on("ready", () => {
+		if (breakerOpen) {
+			console.log("[auth/redis] reconnected");
 		}
+		breakerOpen = false;
+		warned = false;
 	});
 	return client;
 }
@@ -50,29 +80,37 @@ export function createRedisSecondaryStorage(): SecondaryStorage | undefined {
 	}
 	return {
 		async get(key) {
+			if (breakerOpen) {
+				return null;
+			}
 			try {
 				return await redis.get(key);
-			} catch (err) {
-				console.error("[auth/redis] get failed:", (err as Error).message);
+			} catch {
 				return null;
 			}
 		},
 		async set(key, value, ttl) {
+			if (breakerOpen) {
+				return;
+			}
 			try {
 				if (ttl && ttl > 0) {
 					await redis.set(key, value, "EX", ttl);
 				} else {
 					await redis.set(key, value);
 				}
-			} catch (err) {
-				console.error("[auth/redis] set failed:", (err as Error).message);
+			} catch {
+				// Swallow — adapter is best-effort.
 			}
 		},
 		async delete(key) {
+			if (breakerOpen) {
+				return;
+			}
 			try {
 				await redis.del(key);
-			} catch (err) {
-				console.error("[auth/redis] delete failed:", (err as Error).message);
+			} catch {
+				// Swallow.
 			}
 		},
 	};