@apifuse/provider-sdk 2.1.0-beta.5 → 2.1.0-beta.8

package/src/runtime/cache.ts

@@ -1,7 +1,6 @@
 import { createHash } from "node:crypto";
 
-import Redis from "ioredis";
-
+import { providerCacheRedisUrlFromEnv } from "../config/loader";
 import type {
 	ProviderCache,
 	ProviderCacheGetOrSetOptions,
@@ -10,6 +9,12 @@ import type {
 	ProviderCacheResponseMeta,
 	ProviderCacheResult,
 } from "../types";
+import {
+	createProviderRedisClient,
+	ensureRedisReady,
+	type ProviderRedisClient,
+	withRedisTimeout,
+} from "./redis";
 
 type CacheSource = ProviderCacheLookupMeta["source"];
 
@@ -26,7 +31,7 @@ type MemoryEntry = CacheEnvelope & {
 };
 
 type SharedCacheBackend = {
-	redis?: Redis;
+	redis?: ProviderRedisClient;
 	memory: Map<string, MemoryEntry>;
 	inflight: Map<string, Promise<ProviderCacheResult<unknown>>>;
 };
@@ -57,14 +62,6 @@ const SECRET_FIELD_NAMES = new Set([
 
 const sharedBackends = new Map<string, SharedCacheBackend>();
 
-function redisUrlFromEnv(): string | undefined {
-	return (
-		process.env.APIFUSE__PROVIDER__CACHE_REDIS_URL?.trim() ||
-		process.env.APIFUSE__REDIS__URL?.trim() ||
-		undefined
-	);
-}
-
 function backendKey(redisUrl: string | undefined): string {
 	return redisUrl ?? "memory";
 }
@@ -80,15 +77,12 @@ function getSharedBackend(redisUrl: string | undefined): SharedCacheBackend {
 	};
 
 	if (redisUrl) {
-		const redis = new Redis(redisUrl, {
-			connectTimeout: DEFAULT_REDIS_TIMEOUT_MS,
-			enableOfflineQueue: false,
-			lazyConnect: true,
-			maxRetriesPerRequest: 0,
-			retryStrategy: () => null,
-		});
-		redis.on("error", () => {
-			// Fail-open: cache connectivity must never fail provider execution.
+		const redis = createProviderRedisClient({
+			redisUrl,
+			timeoutMs: DEFAULT_REDIS_TIMEOUT_MS,
+			onError: () => {
+				// Fail-open: cache connectivity must never fail provider execution.
+			},
 		});
 		backend.redis = redis;
 	}
@@ -202,77 +196,20 @@ function sourceSummary(
 	return "mixed";
 }
 
-async function withRedisTimeout<T>(
+async function withRedisFallback<T>(
 	operation: () => Promise<T>,
 ): Promise<T | undefined> {
-	let timeoutId: ReturnType<typeof setTimeout> | undefined;
-	try {
-		const timeout = new Promise<undefined>((resolve) => {
-			timeoutId = setTimeout(
-				() => resolve(undefined),
-				DEFAULT_REDIS_TIMEOUT_MS,
-			);
-		});
-		return await Promise.race([operation().catch(() => undefined), timeout]);
-	} finally {
-		if (timeoutId) clearTimeout(timeoutId);
-	}
-}
-
-function redisStatus(redis: Redis): string {
-	return redis.status;
-}
-
-async function waitForRedisReady(redis: Redis): Promise<boolean> {
-	let timeoutId: ReturnType<typeof setTimeout> | undefined;
-	let settled = false;
-
-	return await new Promise<boolean>((resolve) => {
-		const cleanup = () => {
-			if (timeoutId) clearTimeout(timeoutId);
-			redis.off("ready", onReady);
-			redis.off("close", onUnavailable);
-			redis.off("end", onUnavailable);
-			redis.off("error", onUnavailable);
-		};
-		const finish = (ready: boolean) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve(ready);
-		};
-		const onReady = () => finish(true);
-		const onUnavailable = () => finish(false);
-
-		timeoutId = setTimeout(
-			() => finish(redisStatus(redis) === "ready"),
-			DEFAULT_REDIS_TIMEOUT_MS,
-		);
-		redis.once("ready", onReady);
-		redis.once("close", onUnavailable);
-		redis.once("end", onUnavailable);
-		redis.once("error", onUnavailable);
+	return await withRedisTimeout(operation, {
+		timeoutMs: DEFAULT_REDIS_TIMEOUT_MS,
+		onTimeout: () => undefined,
+		onError: () => undefined,
 	});
 }
 
-async function ensureRedisReady(redis: Redis): Promise<boolean> {
-	if (redisStatus(redis) === "ready") return true;
-
-	if (redisStatus(redis) === "wait" || redisStatus(redis) === "end") {
-		const connected = await withRedisTimeout(async () => {
-			await redis.connect();
-			return true;
-		});
-		return connected === true && redisStatus(redis) === "ready";
-	}
-
-	return await waitForRedisReady(redis);
-}
-
 export function createProviderCache(
 	options: ProviderCacheOptions,
 ): ProviderCache {
-	const redisUrl = options.redisUrl ?? redisUrlFromEnv();
+	const redisUrl = options.redisUrl ?? providerCacheRedisUrlFromEnv();
 	const backend = getSharedBackend(redisUrl);
 	const memoryMaxEntries = Math.max(
 		1,
@@ -333,9 +270,11 @@ export function createProviderCache(
 		result: ProviderCacheResult<T>;
 	} | null> {
 		const redis = backend.redis;
-		if (!redis || !(await ensureRedisReady(redis))) return null;
+		if (!redis || !(await ensureRedisReady(redis, DEFAULT_REDIS_TIMEOUT_MS))) {
+			return null;
+		}
 
-		const raw = await withRedisTimeout(async () => {
+		const raw = await withRedisFallback(async () => {
 			return await redis.get(key);
 		});
 		if (typeof raw !== "string" && raw !== null) return null;
@@ -410,8 +349,10 @@ export function createProviderCache(
 		rememberEnvelope(key, envelope, currentTime);
 
 		const redis = backend.redis;
-		if (!redis || !(await ensureRedisReady(redis))) return;
-		await withRedisTimeout(() =>
+		if (!redis || !(await ensureRedisReady(redis, DEFAULT_REDIS_TIMEOUT_MS))) {
+			return;
+		}
+		await withRedisFallback(() =>
 			redis.set(key, JSON.stringify(envelope), "PX", staleTtlMs),
 		);
 	}
@@ -464,8 +405,13 @@ export function createProviderCache(
 		async delete(key: string): Promise<void> {
 			backend.memory.delete(key);
 			const redis = backend.redis;
-			if (!redis || !(await ensureRedisReady(redis))) return;
-			await withRedisTimeout(() => redis.del(key));
+			if (
+				!redis ||
+				!(await ensureRedisReady(redis, DEFAULT_REDIS_TIMEOUT_MS))
+			) {
+				return;
+			}
+			await withRedisFallback(() => redis.del(key));
 		},
 
 		async getOrSet<T = unknown>(