refactor: improve support for persistent queries

Author: mvantellingen

package.json

@@ -59,6 +59,7 @@
 		"@vitest/coverage-v8": "3.0.2",
 		"tsup": "8.3.5",
 		"typescript": "5.7.3",
+		"vite-tsconfig-paths": "5.1.4",
 		"vitest": "3.0.2",
 		"vitest-fetch-mock": "^0.2.2"
 	},

pnpm-lock.yaml

@@ -196,7 +196,7 @@ describe("gqlClientFetch", () => {
 			{
 				myVar: "baz",
 			},
-			controller.signal,
+			{ signal: controller.signal },
 		);
 
 		expect(fetchMock).toHaveBeenCalledWith(

src/client.test.ts

@@ -1,22 +1,32 @@
 import type { DocumentTypeDecoration } from "@graphql-typed-document-node/core";
+import { print } from "graphql";
+import { isNode } from "graphql/language/ast.js";
+import {
+	asRequestBody,
+	asRequestURL,
+	createRequest,
+	isPersistedQuery,
+	type ModeFlags,
+} from "request";
 import invariant from "tiny-invariant";
-import { getDocumentId, type GqlResponse } from "./helpers";
 import {
-	createSha256,
 	errorMessage,
-	extractOperationName,
+	getDocumentId,
 	getQueryType,
 	hasPersistedQueryError,
 	mergeHeaders,
+	type GqlResponse,
 } from "./helpers";
-import { print } from "graphql";
-import { isNode } from "graphql/language/ast.js";
 
 type Options = {
 	/**
-	 * Enable use of persisted queries, this will always add a extra roundtrip to the server if queries aren't cacheable
+	 * Enable use of automated persisted queries, this will always add a extra
+	 * roundtrip to the server if queries aren't cacheable
 	 * @default false
 	 */
+	apq?: boolean;
+
+	/** Deprecated: use `apq: <boolean>` */
 	persistedQueries?: boolean;
 
 	/**
@@ -31,6 +41,8 @@ type Options = {
 	 */
 	defaultHeaders?: Headers | Record<string, string>;
 
+	mode?: ModeFlags
+
 	/**
 	 * Function to customize creating the documentId from a query
 	 *
@@ -49,81 +61,53 @@ type RequestOptions = {
 export type ClientFetcher = <TResponse, TVariables>(
 	astNode: DocumentTypeDecoration<TResponse, TVariables>,
 	variables?: TVariables,
-	options?: RequestOptions | AbortSignal, // Backwards compatibility
+	options?: RequestOptions,
 ) => Promise<GqlResponse<TResponse>>;
 
 export const initClientFetcher =
 	(
 		endpoint: string,
 		{
+			apq = false,
 			persistedQueries = false,
 			defaultTimeout = 30000,
 			defaultHeaders = {},
-			createDocumentId = <TResult, TVariables>(
-				query: DocumentTypeDecoration<TResult, TVariables>,
-			): string | undefined => getDocumentId(query),
+			mode = "document",
+			createDocumentId = getDocumentId,
 		}: Options = {},
 	): ClientFetcher =>
 	/**
 	 * Executes a GraphQL query post request on the client.
 	 *
-	 * This is the only fetcher that uses user information in the call since all user information is only
-	 * used after rendering the page for caching reasons.
+	 * This is the only fetcher that uses user information in the call since all
+	 * user information is only used after rendering the page for caching reasons.
 	 */
 	async <TResponse, TVariables>(
 		astNode: DocumentTypeDecoration<TResponse, TVariables>,
 		variables?: TVariables,
-		optionsOrSignal: RequestOptions | AbortSignal = {
+		options: RequestOptions = {
 			signal: AbortSignal.timeout(defaultTimeout),
-		} satisfies RequestOptions,
+		},
 	): Promise<GqlResponse<TResponse>> => {
-		// For backwards compatibility, when options is an AbortSignal we transform
-		// it into a RequestOptions object
-		const options: RequestOptions = {};
-		if (optionsOrSignal instanceof AbortSignal) {
-			options.signal = optionsOrSignal;
-		} else {
-			Object.assign(options, optionsOrSignal);
-		}
-
 		// Make sure that we always have a default signal set
 		if (!options.signal) {
 			options.signal = AbortSignal.timeout(defaultTimeout);
 		}
 
 		const query = isNode(astNode) ? print(astNode) : astNode.toString();
-
-		const operationName = extractOperationName(query);
 		const documentId = createDocumentId(astNode);
-
-		let extensions = {};
-		if (persistedQueries) {
-			const hash = await createSha256(query);
-
-			extensions = {
-				persistedQuery: {
-					version: 1,
-					sha256Hash: hash,
-				},
-			};
-		}
-
-		const url = new URL(endpoint);
-		url.searchParams.set("op", operationName ?? "");
+		const request = await createRequest(mode, query, variables, documentId);
 
 		let response: GqlResponse<TResponse> | undefined = undefined;
-
 		const headers = mergeHeaders({ ...defaultHeaders, ...options.headers });
 
+		const queryType = getQueryType(query);
+
+		apq = apq || persistedQueries;
+
 		// For queries we can use GET requests if persisted queries are enabled
-		if (persistedQueries && getQueryType(query) === "query") {
-			url.searchParams.set("extensions", JSON.stringify(extensions));
-			if (variables) {
-				url.searchParams.set("variables", JSON.stringify(variables));
-			}
-			if (documentId) {
-				url.searchParams.set("documentId", documentId);
-			}
+		if (queryType === "query" && (apq || isPersistedQuery(request))) {
+			const url = asRequestURL(endpoint, request);
 			response = await parseResponse<GqlResponse<TResponse>>(() =>
 				fetch(url.toString(), {
 					headers: Object.fromEntries(headers.entries()),
@@ -134,13 +118,18 @@ export const initClientFetcher =
 			);
 		}
 
-		if (!response || hasPersistedQueryError(response)) {
-			// Persisted query not used or found, fall back to POST request and include extension to cache the query on the server
+		// For failed APQ calls or mutations we need to fall back to POST requests
+		if (
+			!response ||
+			(isPersistedQuery(request) && hasPersistedQueryError(response))
+		) {
+			// Persisted query not used or found, fall back to POST request and
+			// include extension to cache the query on the server
 			response = await parseResponse<GqlResponse<TResponse>>(() =>
-				fetch(url.toString(), {
+				fetch(endpoint, {
 					headers: Object.fromEntries(headers.entries()),
 					method: "POST",
-					body: JSON.stringify({ documentId, query, variables, extensions }),
+					body: asRequestBody(request),
 					credentials: "include",
 					signal: options.signal,
 				}),

src/client.ts

@@ -28,7 +28,7 @@ export const mergeHeaders = (
 	return result;
 };
 
-export const getQueryType = (query: string) =>
+export const getQueryType = (query: string): "query" | "mutation" =>
 	query.trim().startsWith("query") ? "query" : "mutation";
 
 export const getDocumentId = <TResult, TVariables>(
@@ -55,8 +55,17 @@ export interface NextFetchRequestConfig {
 	tags?: string[];
 }
 
-export const pruneObject = <T>(object: T): Partial<T> =>
-	JSON.parse(JSON.stringify(object ?? null));
+export const pruneObject = <T>(object: T): Partial<T> => {
+	const data: Record<string, unknown> = {}
+	for (const key in object) {
+		if (isNotEmpty(object[key])) {
+			data[key] = object[key];
+		}
+	}
+	return JSON.parse(JSON.stringify(data ?? null));
+}
+
+const isNotEmpty = (value: unknown) => value && Object.keys(value).length > 0;
 
 // createSha256 creates a sha256 hash from a message with the same algorithm as
 // Apollo Server, so we know for certain the same hash is used for automatic