@fourtwelvelabs/fetch-contentful 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -130,6 +130,48 @@ var FetchContentfulError = class extends Error {
 function isFetchContentfulError(value) {
   return value instanceof FetchContentfulError;
 }
+var WORD_LIKE = /* @__PURE__ */ new Set([graphql.TokenKind.NAME, graphql.TokenKind.INT, graphql.TokenKind.FLOAT]);
+function minifyQuery(query) {
+  const lexer = new graphql.Lexer(new graphql.Source(query));
+  let previousKind;
+  let out = "";
+  for (let token = lexer.advance(); token.kind !== graphql.TokenKind.EOF; token = lexer.advance()) {
+    if (previousKind && WORD_LIKE.has(previousKind) && WORD_LIKE.has(token.kind)) {
+      out += " ";
+    }
+    out += query.slice(token.start, token.end);
+    previousKind = token.kind;
+  }
+  return out;
+}
+
+// src/persisted-query.ts
+var PERSISTED_QUERY_VERSION = 1;
+function toHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+async function sha256Hex(query) {
+  const data = new TextEncoder().encode(query);
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle) {
+    const digest = await subtle.digest("SHA-256", data);
+    return toHex(new Uint8Array(digest));
+  }
+  const { createHash } = await import('crypto');
+  return createHash("sha256").update(data).digest("hex");
+}
+function persistedQueryExtensions(sha256Hash) {
+  return { persistedQuery: { version: PERSISTED_QUERY_VERSION, sha256Hash } };
+}
+function isPersistedQueryNotFoundError(error) {
+  if (error.message === "PersistedQueryNotFound") return true;
+  const extensions = error.extensions;
+  return extensions?.code === "PERSISTED_QUERY_NOT_FOUND";
+}
 
 // src/retry.ts
 function defaultSleep(ms) {
@@ -196,6 +238,9 @@ function withDirective(field, name) {
 function responseKeyOf(field) {
   return field.alias?.value ?? field.name.value;
 }
+function hasResponseKey(selection, key) {
+  return selection.kind === graphql.Kind.FIELD && responseKeyOf(selection) === key;
+}
 function isCollectionField(field) {
   if (!field.name.value.endsWith(COLLECTION_SUFFIX) || field.name.value === COLLECTION_SUFFIX || !field.selectionSet) {
     return false;
@@ -326,13 +371,14 @@ function planSplits(document, options) {
       const field = selection;
       const isExplicitSplit = hasDirective(field, SPLIT_DIRECTIVE);
       const isAutoSplit = options.autoSplitNestedCollections && isCollectionField(field);
+      const isForcedSplit = options.forceSplit?.(field) ?? false;
       if (isExplicitSplit && depth === 0) {
         throw new FetchContentfulError(
           `Cannot split root field "${responseKeyOf(field)}": @split needs a parent entry to stitch the result back onto, and root fields have none. Move the directive to a nested field, or page through this field with its own \`limit\` and \`skip\` arguments.`,
           { code: "CONFIG" }
         );
       }
-      const shouldSplit = depth > 0 && field.selectionSet !== void 0 && !hasDirective(field, NO_SPLIT_DIRECTIVE) && (isExplicitSplit || isAutoSplit);
+      const shouldSplit = depth > 0 && field.selectionSet !== void 0 && !hasDirective(field, NO_SPLIT_DIRECTIVE) && (isExplicitSplit || isAutoSplit || isForcedSplit);
       if (shouldSplit) {
         const planned = withDirective(withoutDirective(field, SPLIT_DIRECTIVE), NO_SPLIT_DIRECTIVE);
         plans.push({
@@ -363,8 +409,11 @@ function planSplits(document, options) {
         selections.push(field);
       }
     }
-    if (needsMarkers) {
-      selections.push(sysIdMarker(), typenameMarker());
+    if (needsMarkers && !selections.some((s) => hasResponseKey(s, SYS_ID_ALIAS))) {
+      selections.push(sysIdMarker());
+    }
+    if (needsMarkers && !selections.some((s) => hasResponseKey(s, TYPENAME_ALIAS))) {
+      selections.push(typenameMarker());
     }
     return { ...selectionSet, selections };
   }
@@ -382,6 +431,49 @@ function planSplits(document, options) {
     plans
   };
 }
+function findSplitCandidates(document) {
+  const operation = getOperation(document);
+  const candidates = [];
+  function walk2(selectionSet, depth) {
+    for (const selection of selectionSet.selections) {
+      if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
+        walk2(selection.selectionSet, depth);
+        continue;
+      }
+      if (selection.kind !== graphql.Kind.FIELD || !selection.selectionSet) continue;
+      const isMarker = hasResponseKey(selection, SYS_ID_ALIAS) || hasResponseKey(selection, TYPENAME_ALIAS);
+      if (depth > 0 && selection.name.value !== "items" && !isMarker) {
+        candidates.push({ field: selection, size: graphql.print(selection).length });
+      }
+      walk2(selection.selectionSet, depth + 1);
+    }
+  }
+  walk2(operation.selectionSet, 0);
+  return candidates;
+}
+function planSplitsWithSizeBudget(document, options) {
+  const first = planSplits(document, {
+    autoSplitNestedCollections: options.autoSplitNestedCollections
+  });
+  if (!options.autoSplitOnSize) return first;
+  let outer = first.document;
+  const plans = [...first.plans];
+  let remainingIterations = findSplitCandidates(outer).length;
+  while (options.measure(outer) > options.maxQuerySize && remainingIterations-- > 0) {
+    const candidates = findSplitCandidates(outer);
+    if (candidates.length === 0) break;
+    const target = candidates.reduce(
+      (largest, candidate) => candidate.size > largest.size ? candidate : largest
+    );
+    const next = planSplits(outer, {
+      autoSplitNestedCollections: false,
+      forceSplit: (field) => field === target.field
+    });
+    outer = next.document;
+    plans.push(...next.plans);
+  }
+  return { document: outer, plans };
+}
 function stringArgument(name, value) {
   return {
     kind: graphql.Kind.ARGUMENT,
@@ -550,6 +642,10 @@ function graphqlEndpoint(space, environment) {
     space
   )}/environments/${encodeURIComponent(environment)}`;
 }
+function printOutgoingQuery(document, context) {
+  const printed = graphql.print(stripInternalDirectives(document));
+  return context.minifyQuery === false ? printed : minifyQuery(printed);
+}
 function parseRetryAfter(header) {
   if (!header) return void 0;
   const seconds = Number(header);
@@ -609,13 +705,17 @@ ${annotated}
 ` : message;
 }
 async function rawRequest(document, variables, context) {
-  const query = graphql.print(stripInternalDirectives(document));
-  const body = JSON.stringify({
-    query,
-    variables: pickDeclaredVariables(document, variables)
-  });
+  const query = printOutgoingQuery(document, context);
+  const pickedVariables = pickDeclaredVariables(document, variables);
   const url = graphqlEndpoint(context.space, context.environment);
-  return withRetries(async () => {
+  const usePersistedQuery = context.automaticPersistedQueries === true;
+  const sha256Hash = usePersistedQuery ? await sha256Hex(query) : void 0;
+  async function send(includeQuery) {
+    const body = JSON.stringify({
+      ...includeQuery ? { query } : {},
+      variables: pickedVariables,
+      ...sha256Hash ? { extensions: persistedQueryExtensions(sha256Hash) } : {}
+    });
     let response;
     try {
       const init = {
@@ -685,6 +785,21 @@ async function rawRequest(document, variables, context) {
       });
     }
     return payload.data;
+  }
+  let mustIncludeQuery = !usePersistedQuery;
+  return withRetries(async () => {
+    if (mustIncludeQuery) {
+      return send(true);
+    }
+    try {
+      return await send(false);
+    } catch (error) {
+      if (isFetchContentfulError(error) && error.code === "GRAPHQL" && error.errors?.some(isPersistedQueryNotFoundError)) {
+        mustIncludeQuery = true;
+        return await send(true);
+      }
+      throw error;
+    }
   }, context.retry);
 }
 
@@ -890,6 +1005,8 @@ var DEFAULT_RETRIES = 5;
 var DEFAULT_RETRY_DELAY_MS = 250;
 var DEFAULT_MAX_RETRY_DELAY_MS = 8e3;
 var DEFAULT_SPLIT_BATCH_SIZE = 50;
+var DEFAULT_MAX_QUERY_SIZE = 7500;
+var DEFAULT_MAX_QUERY_SIZE_WITH_APQ = 15500;
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -940,6 +1057,7 @@ function resolveContext(options) {
     maxDelayMs: options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS
   };
   const fetchImpl = options.fetch ?? globalThis.fetch;
+  const automaticPersistedQueries = options.automaticPersistedQueries ?? false;
   const context = {
     space,
     environment,
@@ -950,9 +1068,15 @@ function resolveContext(options) {
     fetch: fetchImpl,
     retry,
     autoSplitNestedCollections: options.autoSplitNestedCollections ?? true,
+    autoSplitOnSize: options.autoSplitOnSize ?? true,
+    // APQ lifts Contentful's size ceiling from 8 KB to 16 KB, so the budget
+    // that triggers a size-driven split follows suit unless overridden.
+    maxQuerySize: options.maxQuerySize ?? (automaticPersistedQueries ? DEFAULT_MAX_QUERY_SIZE_WITH_APQ : DEFAULT_MAX_QUERY_SIZE),
     splitBatchSize: options.splitBatchSize ?? DEFAULT_SPLIT_BATCH_SIZE,
     annotateQueryOnError: options.annotateQueryOnError ?? true,
-    unresolvableLinks: options.unresolvableLinks ?? "omit"
+    unresolvableLinks: options.unresolvableLinks ?? "omit",
+    minifyQuery: options.minifyQuery ?? true,
+    automaticPersistedQueries
   };
   if (options.onUnresolvableLink) {
     context.onUnresolvableLink = options.onUnresolvableLink;
@@ -1044,8 +1168,16 @@ function cleanupMarkers(data, plans) {
     }
   }
 }
+function byteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
 async function executeDocument(document, variables, context) {
-  const { document: outer, plans } = planSplits(document, context);
+  const { document: outer, plans } = planSplitsWithSizeBudget(document, {
+    autoSplitNestedCollections: context.autoSplitNestedCollections,
+    autoSplitOnSize: context.autoSplitOnSize,
+    maxQuerySize: context.maxQuerySize,
+    measure: (doc) => byteLength(printOutgoingQuery(doc, context))
+  });
   const data = await rawRequest(outer, variables, context);
   await Promise.all(plans.map((plan) => resolvePlan(plan, data, variables, context)));
   cleanupMarkers(data, plans);
@@ -1136,6 +1268,7 @@ exports.injectRootArgs = injectRootArgs;
 exports.inlineFragments = inlineFragments;
 exports.isFetchContentfulError = isFetchContentfulError;
 exports.isUnresolvableLinkError = isUnresolvableLinkError;
+exports.minifyQuery = minifyQuery;
 exports.omitUnresolvedLinks = omitUnresolvedLinks;
 exports.partitionUnresolvableLinks = partitionUnresolvableLinks;
 exports.readEnvSettings = readEnvSettings;