@apifuse/provider-sdk 2.2.0-beta.3 → 2.2.0-beta.31

package/src/runtime/redirects.ts

@@ -0,0 +1,66 @@
+import type { HttpRedirectFailureReason } from "../types.js";
+
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+
+export type RedirectHopDecision<TMethod extends string> =
+	| {
+			kind: "follow";
+			nextMethod: TMethod | "GET";
+			nextUrl: string;
+	  }
+	| {
+			kind: "stop";
+			reason: HttpRedirectFailureReason;
+			nextUrl?: string;
+	  };
+
+export function isRedirectStatus(status: number): boolean {
+	return REDIRECT_STATUSES.has(status);
+}
+
+/** Shared fetch-compatible redirect method rewriting for stealth and ctx.http. */
+export function nextRedirectMethod<TMethod extends string>(
+	status: number,
+	method: TMethod,
+): TMethod | "GET" {
+	if (status === 303 && method !== "HEAD") return "GET";
+	if ((status === 301 || status === 302) && method === "POST") return "GET";
+	return method;
+}
+
+/** Resolves a Location value against the response URL without issuing a request. */
+export function resolveRedirectUrl(
+	location: string | undefined,
+	responseUrl: string,
+): string | undefined {
+	return location ? new URL(location, responseUrl).toString() : undefined;
+}
+
+/**
+ * Shared post-response decision ordering for both redirect walkers. The
+ * caller-owned stop hook is checked first, matching stealth's pre-follow
+ * contract, then structural termination and loop checks run before follow.
+ */
+export function evaluateRedirectHop<TMethod extends string>(input: {
+	status: number;
+	method: TMethod;
+	nextUrl: string | undefined;
+	shouldStop: boolean;
+	redirectCount: number;
+	maxHops: number;
+	visitedRequests: ReadonlySet<string>;
+}): RedirectHopDecision<TMethod> {
+	if (input.shouldStop) {
+		return { kind: "stop", reason: "stopped", ...(input.nextUrl ? { nextUrl: input.nextUrl } : {}) };
+	}
+	if (!input.nextUrl) return { kind: "stop", reason: "missing_location" };
+	if (input.redirectCount > input.maxHops) {
+		return { kind: "stop", reason: "max_hops", nextUrl: input.nextUrl };
+	}
+
+	const nextMethod = nextRedirectMethod(input.status, input.method);
+	if (input.visitedRequests.has(`${nextMethod} ${input.nextUrl}`)) {
+		return { kind: "stop", reason: "loop", nextUrl: input.nextUrl };
+	}
+	return { kind: "follow", nextMethod, nextUrl: input.nextUrl };
+}

package/src/runtime/redis.ts

@@ -1,4 +1,8 @@
-import Redis from "ioredis";
+import { createRequire } from "node:module";
+
+import type { Redis } from "ioredis";
+
+const require = createRequire(import.meta.url);
 
 export type ProviderRedisClient = Redis;
 
@@ -17,7 +21,8 @@ type RedisTimeoutOptions<T> = {
 export function createProviderRedisClient(
 	options: ProviderRedisClientOptions,
 ): ProviderRedisClient {
-	const redis = new Redis(options.redisUrl, {
+	const { Redis: RedisClient } = require("ioredis") as typeof import("ioredis");
+	const redis = new RedisClient(options.redisUrl, {
 		connectTimeout: options.timeoutMs,
 		enableOfflineQueue: false,
 		lazyConnect: true,
@@ -43,9 +48,7 @@ export async function withRedisTimeout<T>(
 				}
 			}, options.timeoutMs);
 		});
-		const operationResult = options.onError
-			? operation().catch(options.onError)
-			: operation();
+		const operationResult = options.onError ? operation().catch(options.onError) : operation();
 		return await Promise.race([operationResult, timeout]);
 	} finally {
 		if (timeoutId) clearTimeout(timeoutId);
@@ -56,10 +59,7 @@ export function redisStatus(redis: ProviderRedisClient): string {
 	return redis.status;
 }
 
-async function waitForRedisReady(
-	redis: ProviderRedisClient,
-	timeoutMs: number,
-): Promise<boolean> {
+async function waitForRedisReady(redis: ProviderRedisClient, timeoutMs: number): Promise<boolean> {
 	let timeoutId: ReturnType<typeof setTimeout> | undefined;
 	let settled = false;
 
@@ -80,10 +80,7 @@ async function waitForRedisReady(
 		const onReady = () => finish(true);
 		const onUnavailable = () => finish(false);
 
-		timeoutId = setTimeout(
-			() => finish(redisStatus(redis) === "ready"),
-			timeoutMs,
-		);
+		timeoutId = setTimeout(() => finish(redisStatus(redis) === "ready"), timeoutMs);
 		redis.once("ready", onReady);
 		redis.once("close", onUnavailable);
 		redis.once("end", onUnavailable);