Context7 Platform -- Up-to-date docs for AI agents
fix(sdk): honor cancellation while awaiting auth tokens (#3264)
Mohit Nirmal88618087fca5
diff --git a/.changeset/quiet-tokens-wait.md b/.changeset/quiet-tokens-wait.mdnew file mode 100644index 00000000..c02e8d37--- /dev/null+++ b/.changeset/quiet-tokens-wait.md@@ -0,0 +1,5 @@+---+"@upstash/context7-sdk": patch+---++Honor request timeouts and cancellation while waiting for an asynchronous authentication token provider.diff --git a/packages/sdk/src/http/abort.ts b/packages/sdk/src/http/abort.tsindex 096ce042..aabe4dd4 100644--- a/packages/sdk/src/http/abort.ts+++ b/packages/sdk/src/http/abort.ts@@ -78,6 +78,28 @@ export function isContext7AbortError(error: unknown): boolean {);}+/** Stop waiting on a value when cancelled, without cancelling its underlying work. */+export async function awaitWithSignal<T>(+ value: T | PromiseLike<T>,+ signal?: AbortSignal+): Promise<T> {+ if (!signal) return value;++ let onAbort!: () => void;+ const aborted = new Promise<never>((_resolve, reject) => {+ onAbort = () => reject(signal.reason);+ if (signal.aborted) onAbort();+ else signal.addEventListener("abort", onAbort, { once: true });+ });++ try {+ // Keep a rejection handler on the provider even if cancellation wins the race.+ return await Promise.race([value, aborted]);+ } finally {+ signal.removeEventListener("abort", onAbort);+ }+}+export async function wait(milliseconds: number, signal?: AbortSignal): Promise<void> {if (milliseconds <= 0) return;diff --git a/packages/sdk/src/http/index.test.ts b/packages/sdk/src/http/index.test.tsindex 8869226d..1521100d 100644--- a/packages/sdk/src/http/index.test.ts+++ b/packages/sdk/src/http/index.test.ts@@ -124,6 +124,107 @@ describe("HttpClient error handling", () => {expect(fetchMock).toHaveBeenCalledTimes(2);});+ test("times out while an auth token provider is still pending", async () => {+ vi.useFakeTimers();+ const authToken = vi.fn(() => new Promise<string>(() => {}));+ const fetchMock = vi.fn();+ const client = new HttpClient({+ baseUrl: "https://example.com/api",+ authToken,+ fetch: fetchMock,+ timeout: 25,+ });+ const onError = vi.fn();+ const request = client.request({ method: "GET" }).catch(onError);++ await vi.advanceTimersByTimeAsync(25);++ expect(onError).toHaveBeenCalledWith(+ expect.objectContaining({ code: "request_timeout", retryable: true })+ );+ await request;+ expect(authToken).toHaveBeenCalledOnce();+ expect(fetchMock).not.toHaveBeenCalled();+ expect(vi.getTimerCount()).toBe(0);+ });++ test.each(["resolve", "reject"] as const)(+ "cancels a pending token wait and handles a late provider %s",+ async (settlement) => {+ vi.useFakeTimers();+ const controller = new AbortController();+ let resolveToken!: (token: string) => void;+ let rejectToken!: (error: Error) => void;+ const authToken = vi.fn(+ () =>+ new Promise<string>((resolve, reject) => {+ resolveToken = resolve;+ rejectToken = reject;+ })+ );+ const fetchMock = vi.fn();+ const client = new HttpClient({+ baseUrl: "https://example.com/api",+ authToken,+ fetch: fetchMock,+ timeout: false,+ });+ const onError = vi.fn();+ const request = client.request({ method: "GET", signal: controller.signal }).catch(onError);+ const reason = new Error("User cancelled");+ controller.abort(reason);+ await vi.advanceTimersByTimeAsync(0);++ expect(onError).toHaveBeenCalledWith(+ expect.objectContaining({ code: "request_aborted", retryable: false, cause: reason })+ );+ await request;++ if (settlement === "resolve") resolveToken("late-token");+ else rejectToken(new Error("Late provider failure"));+ await vi.advanceTimersByTimeAsync(0);++ expect(onError).toHaveBeenCalledOnce();+ expect(authToken).toHaveBeenCalledOnce();+ expect(fetchMock).not.toHaveBeenCalled();+ }+ );++ test("handles cancellation triggered synchronously by the token provider", async () => {+ const controller = new AbortController();+ const fetchMock = vi.fn();+ const client = new HttpClient({+ baseUrl: "https://example.com/api",+ authToken: () => {+ controller.abort();+ return Promise.reject(new Error("Provider failed after cancellation"));+ },+ fetch: fetchMock,+ });++ await expect(client.request({ signal: controller.signal })).rejects.toMatchObject({+ code: "request_aborted",+ retryable: false,+ });+ expect(fetchMock).not.toHaveBeenCalled();+ });++ test.each([true, false])("preserves token provider errors with timeout=%s", async (timeout) => {+ const providerError = new Error("Token service unavailable");+ const authToken = vi.fn().mockRejectedValue(providerError);+ const fetchMock = vi.fn();+ const client = new HttpClient({+ baseUrl: "https://example.com/api",+ authToken,+ fetch: fetchMock,+ timeout: timeout ? 25 : false,+ });++ await expect(client.request({ method: "GET" })).rejects.toBe(providerError);+ expect(authToken).toHaveBeenCalledOnce();+ expect(fetchMock).not.toHaveBeenCalled();+ });+test("uses the last failure when a retry later fails on the network", async () => {const fetchMock = vi.fn()diff --git a/packages/sdk/src/http/index.ts b/packages/sdk/src/http/index.tsindex 98fa46b5..d59b077d 100644--- a/packages/sdk/src/http/index.ts+++ b/packages/sdk/src/http/index.ts@@ -1,6 +1,7 @@import { Context7Error, Context7UrlError } from "@error";import {abortError,+ awaitWithSignal,createAbortState,isContext7AbortError,resolveSignal,@@ -120,9 +121,12 @@ export class HttpClient implements Requester {const canRetry = method === "GET";for (let attempt = 0; attempt <= this.retry.retries; attempt++) {+ if (abortState.signal?.aborted) {+ throw abortError(abortState.signal.reason, abortState.timedOut());+ }const headers =typeof this.authToken === "function"- ? this.headersForToken(await this.authToken())+ ? this.headersForToken(await awaitWithSignal(this.authToken(), abortState.signal)): this.headersForToken(this.authToken);if (abortState.signal?.aborted) {throw abortError(abortState.signal.reason, abortState.timedOut());