@fourtwelvelabs/fetch-contentful 0.1.0

package/dist/index.mjs

@@ -0,0 +1,961 @@
+import { Kind, parse, print, visit } from 'graphql';
+
+// src/index.ts
+
+// src/errors.ts
+var FetchContentfulError = class extends Error {
+  code;
+  status;
+  errors;
+  /** Internal: whether a retry may succeed. */
+  retryable;
+  /** Internal: server-requested retry delay (from Retry-After), in ms. */
+  retryAfterMs;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = "FetchContentfulError";
+    this.code = options.code;
+    this.status = options.status;
+    this.errors = options.errors;
+    this.retryable = options.retryable ?? false;
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+function isFetchContentfulError(value) {
+  return value instanceof FetchContentfulError;
+}
+
+// src/retry.ts
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffDelay(attempt, config) {
+  const exponential = config.baseDelayMs * 2 ** attempt;
+  const jitter = config.random() * config.baseDelayMs;
+  return Math.min(exponential + jitter, config.maxDelayMs);
+}
+async function withRetries(fn, config) {
+  const random = config.random ?? Math.random;
+  const sleep = config.sleep ?? defaultSleep;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      const retryable = isFetchContentfulError(error) && error.retryable;
+      if (!retryable || attempt >= config.retries) {
+        throw error;
+      }
+      const delay = error.retryAfterMs ?? backoffDelay(attempt, { ...config, random });
+      await sleep(delay);
+      attempt += 1;
+    }
+  }
+}
+var SPLIT_DIRECTIVE = "split";
+var NO_SPLIT_DIRECTIVE = "_noSplit";
+var SYS_ID_ALIAS = "_splitSysId";
+var TYPENAME_ALIAS = "_splitTypename";
+var IDS_VARIABLE = "_splitIds";
+var COLLECTION_SUFFIX = "Collection";
+function lowerFirst(value) {
+  return value.charAt(0).toLowerCase() + value.slice(1);
+}
+function chunk(items, size) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}
+function directivesOf(field) {
+  return field.directives ?? [];
+}
+function hasDirective(field, name) {
+  return directivesOf(field).some((d) => d.name.value === name);
+}
+function withoutDirective(field, name) {
+  return {
+    ...field,
+    directives: directivesOf(field).filter((d) => d.name.value !== name)
+  };
+}
+function withDirective(field, name) {
+  const directive = {
+    kind: Kind.DIRECTIVE,
+    name: { kind: Kind.NAME, value: name }
+  };
+  return { ...field, directives: [...directivesOf(field), directive] };
+}
+function responseKeyOf(field) {
+  return field.alias?.value ?? field.name.value;
+}
+function isCollectionField(field) {
+  if (!field.name.value.endsWith(COLLECTION_SUFFIX) || field.name.value === COLLECTION_SUFFIX || !field.selectionSet) {
+    return false;
+  }
+  return field.selectionSet.selections.some(
+    (selection) => selection.kind === Kind.FIELD && selection.name.value === "items"
+  );
+}
+function namedField(name, alias, selections) {
+  return {
+    kind: Kind.FIELD,
+    name: { kind: Kind.NAME, value: name },
+    ...alias ? { alias: { kind: Kind.NAME, value: alias } } : {},
+    ...selections ? {
+      selectionSet: {
+        kind: Kind.SELECTION_SET,
+        selections
+      }
+    } : {}
+  };
+}
+function sysIdMarker() {
+  return namedField("sys", SYS_ID_ALIAS, [namedField("id")]);
+}
+function typenameMarker() {
+  return namedField("__typename", TYPENAME_ALIAS);
+}
+function collectVariableNames(field) {
+  const names = /* @__PURE__ */ new Set();
+  visit(field, {
+    Variable(node) {
+      names.add(node.name.value);
+    }
+  });
+  return names;
+}
+function getOperation(document) {
+  const operations = document.definitions.filter(
+    (definition) => definition.kind === Kind.OPERATION_DEFINITION
+  );
+  const operation = operations[0];
+  if (!operation || operations.length > 1) {
+    throw new FetchContentfulError(
+      "fetch-contentful expects exactly one operation per document.",
+      { code: "CONFIG" }
+    );
+  }
+  if (operation.operation !== "query") {
+    throw new FetchContentfulError(
+      "fetch-contentful only supports query operations.",
+      { code: "CONFIG" }
+    );
+  }
+  return operation;
+}
+function inlineFragments(document) {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const definition of document.definitions) {
+    if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+      fragments.set(definition.name.value, definition);
+    }
+  }
+  function inlineSelectionSet(selectionSet, stack) {
+    const selections = selectionSet.selections.map(
+      (selection) => {
+        if (selection.kind === Kind.FRAGMENT_SPREAD) {
+          const name = selection.name.value;
+          const fragment = fragments.get(name);
+          if (!fragment) {
+            throw new FetchContentfulError(
+              `Unknown fragment "${name}" referenced in query.`,
+              { code: "CONFIG" }
+            );
+          }
+          if (stack.includes(name)) {
+            throw new FetchContentfulError(
+              `Fragment cycle detected involving "${name}".`,
+              { code: "CONFIG" }
+            );
+          }
+          return {
+            kind: Kind.INLINE_FRAGMENT,
+            typeCondition: fragment.typeCondition,
+            selectionSet: inlineSelectionSet(fragment.selectionSet, [
+              ...stack,
+              name
+            ])
+          };
+        }
+        if (selection.selectionSet) {
+          return {
+            ...selection,
+            selectionSet: inlineSelectionSet(selection.selectionSet, stack)
+          };
+        }
+        return selection;
+      }
+    );
+    return { ...selectionSet, selections };
+  }
+  const definitions = document.definitions.filter((definition) => definition.kind !== Kind.FRAGMENT_DEFINITION).map(
+    (definition) => definition.kind === Kind.OPERATION_DEFINITION ? {
+      ...definition,
+      selectionSet: inlineSelectionSet(definition.selectionSet, [])
+    } : definition
+  );
+  return { ...document, definitions };
+}
+function planSplits(document, options) {
+  const operation = getOperation(document);
+  const variableDefinitions = operation.variableDefinitions ?? [];
+  const plans = [];
+  function processSelectionSet(selectionSet, path, depth, typeCondition) {
+    const selections = [];
+    let needsMarkers = false;
+    for (const selection of selectionSet.selections) {
+      if (selection.kind === Kind.INLINE_FRAGMENT) {
+        const condition = selection.typeCondition?.name.value;
+        selections.push({
+          ...selection,
+          selectionSet: processSelectionSet(
+            selection.selectionSet,
+            path,
+            depth,
+            // `Entry` is Contentful's interface type: it never equals a
+            // concrete `__typename`, so it must not constrain the plan.
+            condition && condition !== "Entry" ? condition : typeCondition
+          )
+        });
+        continue;
+      }
+      if (selection.kind !== Kind.FIELD) {
+        throw new FetchContentfulError(
+          "Fragment spreads must be inlined before split planning.",
+          { code: "CONFIG" }
+        );
+      }
+      const field = selection;
+      const shouldSplit = depth > 0 && field.selectionSet !== void 0 && !hasDirective(field, NO_SPLIT_DIRECTIVE) && (hasDirective(field, SPLIT_DIRECTIVE) || options.autoSplitNestedCollections && isCollectionField(field));
+      if (shouldSplit) {
+        const planned = withDirective(
+          withoutDirective(field, SPLIT_DIRECTIVE),
+          NO_SPLIT_DIRECTIVE
+        );
+        plans.push({
+          path: [...path],
+          responseKey: responseKeyOf(field),
+          field: planned,
+          variableDefinitions: variableDefinitions.filter(
+            (definition) => collectVariableNames(field).has(definition.variable.name.value)
+          ),
+          ...typeCondition !== void 0 ? { typeCondition } : {}
+        });
+        needsMarkers = true;
+        continue;
+      }
+      if (field.selectionSet) {
+        selections.push({
+          ...field,
+          selectionSet: processSelectionSet(
+            field.selectionSet,
+            [...path, responseKeyOf(field)],
+            depth + 1,
+            // Type conditions do not carry across a field boundary: the
+            // field's own type governs its children.
+            void 0
+          )
+        });
+      } else {
+        selections.push(field);
+      }
+    }
+    if (needsMarkers) {
+      selections.push(sysIdMarker(), typenameMarker());
+    }
+    return { ...selectionSet, selections };
+  }
+  const processedOperation = {
+    ...operation,
+    selectionSet: processSelectionSet(operation.selectionSet, [], 0, void 0)
+  };
+  return {
+    document: {
+      ...document,
+      definitions: document.definitions.map(
+        (definition) => definition === operation ? processedOperation : definition
+      )
+    },
+    plans
+  };
+}
+function stringArgument(name, value) {
+  return {
+    kind: Kind.ARGUMENT,
+    name: { kind: Kind.NAME, value: name },
+    value: { kind: Kind.STRING, value }
+  };
+}
+function booleanArgument(name, value) {
+  return {
+    kind: Kind.ARGUMENT,
+    name: { kind: Kind.NAME, value: name },
+    value: { kind: Kind.BOOLEAN, value }
+  };
+}
+function intArgument(name, value) {
+  return {
+    kind: Kind.ARGUMENT,
+    name: { kind: Kind.NAME, value: name },
+    value: { kind: Kind.INT, value: String(value) }
+  };
+}
+function whereIdInArgument() {
+  return {
+    kind: Kind.ARGUMENT,
+    name: { kind: Kind.NAME, value: "where" },
+    value: {
+      kind: Kind.OBJECT,
+      fields: [
+        {
+          kind: Kind.OBJECT_FIELD,
+          name: { kind: Kind.NAME, value: "sys" },
+          value: {
+            kind: Kind.OBJECT,
+            fields: [
+              {
+                kind: Kind.OBJECT_FIELD,
+                name: { kind: Kind.NAME, value: "id_in" },
+                value: {
+                  kind: Kind.VARIABLE,
+                  name: { kind: Kind.NAME, value: IDS_VARIABLE }
+                }
+              }
+            ]
+          }
+        }
+      ]
+    }
+  };
+}
+function buildSubquery(plan, typename, batchSize, context) {
+  const rootKey = `${lowerFirst(typename)}${COLLECTION_SUFFIX}`;
+  const args = [
+    whereIdInArgument(),
+    intArgument("limit", batchSize)
+  ];
+  if (context.preview) {
+    args.push(booleanArgument("preview", true));
+  }
+  if (context.locale !== void 0) {
+    args.push(stringArgument("locale", context.locale));
+  }
+  const rootField = {
+    ...namedField(rootKey, void 0, [
+      namedField("items", void 0, [
+        namedField("sys", void 0, [namedField("id")]),
+        plan.field
+      ])
+    ]),
+    arguments: args
+  };
+  const idsVariable = {
+    kind: Kind.VARIABLE_DEFINITION,
+    variable: {
+      kind: Kind.VARIABLE,
+      name: { kind: Kind.NAME, value: IDS_VARIABLE }
+    },
+    type: {
+      kind: Kind.NON_NULL_TYPE,
+      type: {
+        kind: Kind.LIST_TYPE,
+        type: {
+          kind: Kind.NON_NULL_TYPE,
+          type: {
+            kind: Kind.NAMED_TYPE,
+            name: { kind: Kind.NAME, value: "String" }
+          }
+        }
+      }
+    }
+  };
+  const operation = {
+    kind: Kind.OPERATION_DEFINITION,
+    operation: "query",
+    name: { kind: Kind.NAME, value: "FetchContentfulSplit" },
+    variableDefinitions: [idsVariable, ...plan.variableDefinitions],
+    selectionSet: {
+      kind: Kind.SELECTION_SET,
+      selections: [rootField]
+    }
+  };
+  return {
+    document: { kind: Kind.DOCUMENT, definitions: [operation] },
+    rootKey
+  };
+}
+function stripInternalDirectives(document) {
+  return visit(document, {
+    Directive(node) {
+      if (node.name.value === SPLIT_DIRECTIVE || node.name.value === NO_SPLIT_DIRECTIVE) {
+        return null;
+      }
+      return void 0;
+    }
+  });
+}
+
+// src/client.ts
+function graphqlEndpoint(space, environment) {
+  return `https://graphql.contentful.com/content/v1/spaces/${encodeURIComponent(
+    space
+  )}/environments/${encodeURIComponent(environment)}`;
+}
+function parseRetryAfter(header) {
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
+  }
+  const date = Date.parse(header);
+  if (Number.isFinite(date)) {
+    return Math.max(0, date - Date.now());
+  }
+  return void 0;
+}
+function pickDeclaredVariables(document, variables) {
+  const declared = new Set(
+    (getOperation(document).variableDefinitions ?? []).map(
+      (definition) => definition.variable.name.value
+    )
+  );
+  const picked = {};
+  for (const [name, value] of Object.entries(variables)) {
+    if (declared.has(name)) {
+      picked[name] = value;
+    }
+  }
+  return picked;
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+async function rawRequest(document, variables, context) {
+  const query = print(stripInternalDirectives(document));
+  const body = JSON.stringify({
+    query,
+    variables: pickDeclaredVariables(document, variables)
+  });
+  const url = graphqlEndpoint(context.space, context.environment);
+  return withRetries(async () => {
+    let response;
+    try {
+      const init = {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${context.token}`
+        },
+        body
+      };
+      if (context.signal) init.signal = context.signal;
+      if (context.cache) init.cache = context.cache;
+      if (context.next) init.next = context.next;
+      response = await context.fetch(url, init);
+    } catch (cause) {
+      throw new FetchContentfulError(
+        `Network error while contacting Contentful: ${String(cause)}`,
+        { code: "NETWORK", retryable: true, cause }
+      );
+    }
+    if (!response.ok) {
+      const retryable = isRetryableStatus(response.status);
+      throw new FetchContentfulError(
+        `Contentful responded with HTTP ${response.status}.`,
+        {
+          code: "HTTP",
+          status: response.status,
+          retryable,
+          retryAfterMs: retryable ? parseRetryAfter(response.headers.get("Retry-After")) : void 0
+        }
+      );
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch (cause) {
+      throw new FetchContentfulError(
+        "Contentful returned an unreadable response body.",
+        { code: "NETWORK", retryable: true, cause }
+      );
+    }
+    if (payload.errors && payload.errors.length > 0) {
+      throw new FetchContentfulError(
+        `Contentful returned GraphQL errors: ${payload.errors.map((error) => error.message).join("; ")}`,
+        { code: "GRAPHQL", errors: payload.errors }
+      );
+    }
+    if (!payload.data || typeof payload.data !== "object") {
+      throw new FetchContentfulError(
+        "Contentful returned no data and no errors.",
+        { code: "GRAPHQL" }
+      );
+    }
+    return payload.data;
+  }, context.retry);
+}
+
+// src/env.ts
+function orUndefined(value) {
+  return value || void 0;
+}
+function readEnvSettings() {
+  if (typeof process === "undefined" || !process.env) {
+    return {
+      space: void 0,
+      environment: void 0,
+      token: void 0,
+      previewToken: void 0
+    };
+  }
+  return {
+    space: orUndefined(
+      process.env.CONTENTFUL_SPACE_ID || process.env.NEXT_PUBLIC_CONTENTFUL_SPACE_ID
+    ),
+    environment: orUndefined(
+      process.env.CONTENTFUL_ENVIRONMENT || process.env.NEXT_PUBLIC_CONTENTFUL_ENVIRONMENT
+    ),
+    token: orUndefined(
+      process.env.CONTENTFUL_ACCESS_TOKEN || process.env.NEXT_PUBLIC_CONTENTFUL_ACCESS_TOKEN
+    ),
+    previewToken: orUndefined(
+      process.env.CONTENTFUL_PREVIEW_ACCESS_TOKEN || process.env.NEXT_PUBLIC_CONTENTFUL_PREVIEW_ACCESS_TOKEN
+    )
+  };
+}
+function argumentsOf(field) {
+  return field.arguments ?? [];
+}
+function hasArgument(field, name) {
+  return argumentsOf(field).some((argument) => argument.name.value === name);
+}
+function previewArgument() {
+  return {
+    kind: Kind.ARGUMENT,
+    name: { kind: Kind.NAME, value: "preview" },
+    value: { kind: Kind.BOOLEAN, value: true }
+  };
+}
+function localeArgument(locale) {
+  return {
+    kind: Kind.ARGUMENT,
+    name: { kind: Kind.NAME, value: "locale" },
+    value: { kind: Kind.STRING, value: locale }
+  };
+}
+function injectIntoField(field, args) {
+  if (field.name.value.startsWith("__")) {
+    return field;
+  }
+  const additions = [];
+  if (args.preview && !hasArgument(field, "preview")) {
+    additions.push(previewArgument());
+  }
+  if (args.locale !== void 0 && !hasArgument(field, "locale")) {
+    additions.push(localeArgument(args.locale));
+  }
+  if (additions.length === 0) {
+    return field;
+  }
+  return { ...field, arguments: [...argumentsOf(field), ...additions] };
+}
+function injectIntoSelectionSet(selectionSet, args) {
+  const selections = selectionSet.selections.map(
+    (selection) => {
+      if (selection.kind === Kind.FIELD) {
+        return injectIntoField(selection, args);
+      }
+      if (selection.kind === Kind.INLINE_FRAGMENT) {
+        return {
+          ...selection,
+          selectionSet: injectIntoSelectionSet(selection.selectionSet, args)
+        };
+      }
+      return selection;
+    }
+  );
+  return { ...selectionSet, selections };
+}
+function injectRootArgs(document, args) {
+  if (!args.preview && args.locale === void 0) {
+    return document;
+  }
+  const operation = getOperation(document);
+  const injected = {
+    ...operation,
+    selectionSet: injectIntoSelectionSet(operation.selectionSet, args)
+  };
+  return {
+    ...document,
+    definitions: document.definitions.map(
+      (definition) => definition === operation ? injected : definition
+    )
+  };
+}
+
+// src/locales.ts
+var cache = /* @__PURE__ */ new Map();
+function cacheKey(context) {
+  return `${context.space}:${context.environment}:${context.preview ? 1 : 0}`;
+}
+function localesEndpoint(context) {
+  const host = context.preview ? "preview.contentful.com" : "cdn.contentful.com";
+  return `https://${host}/spaces/${encodeURIComponent(
+    context.space
+  )}/environments/${encodeURIComponent(context.environment)}/locales`;
+}
+async function fetchLocales(context) {
+  return withRetries(async () => {
+    let response;
+    try {
+      const init = {
+        headers: { Authorization: `Bearer ${context.token}` }
+      };
+      if (context.signal) init.signal = context.signal;
+      response = await context.fetch(localesEndpoint(context), init);
+    } catch (cause) {
+      throw new FetchContentfulError(
+        `Network error while fetching locales: ${String(cause)}`,
+        { code: "NETWORK", retryable: true, cause }
+      );
+    }
+    if (!response.ok) {
+      throw new FetchContentfulError(
+        `Locale request failed with HTTP ${response.status}.`,
+        {
+          code: "HTTP",
+          status: response.status,
+          retryable: response.status === 429 || response.status >= 500
+        }
+      );
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload.items)) {
+      throw new FetchContentfulError(
+        "Locale response did not include an items array.",
+        { code: "NETWORK" }
+      );
+    }
+    return payload.items.map((item) => ({
+      code: item.code,
+      name: item.name,
+      default: item.default,
+      fallbackCode: item.fallbackCode
+    }));
+  }, context.retry);
+}
+function getLocales(context) {
+  const key = cacheKey(context);
+  const cached = cache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const pending = fetchLocales(context).catch((error) => {
+    cache.delete(key);
+    throw error;
+  });
+  cache.set(key, pending);
+  return pending;
+}
+function clearLocaleCache() {
+  cache.clear();
+}
+
+// src/shape.ts
+var COLLECTION_SUFFIX2 = "Collection";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCollectionValue(value) {
+  return isRecord(value) && Array.isArray(value["items"]);
+}
+function shapeData(data) {
+  if (Array.isArray(data)) {
+    return data.map((item) => shapeData(item));
+  }
+  if (isRecord(data)) {
+    const shaped = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (key.endsWith(COLLECTION_SUFFIX2) && key !== COLLECTION_SUFFIX2 && isCollectionValue(value)) {
+        shaped[key.slice(0, -COLLECTION_SUFFIX2.length)] = shapeData(
+          value.items
+        );
+      } else {
+        shaped[key] = shapeData(value);
+      }
+    }
+    return shaped;
+  }
+  return data;
+}
+function unwrapSingleRoot(data) {
+  if (isRecord(data)) {
+    const keys = Object.keys(data);
+    if (keys.length === 1) {
+      return data[keys[0]];
+    }
+  }
+  return data;
+}
+
+// src/index.ts
+var DEFAULT_RETRIES = 5;
+var DEFAULT_RETRY_DELAY_MS = 250;
+var DEFAULT_MAX_RETRY_DELAY_MS = 8e3;
+var DEFAULT_SPLIT_BATCH_SIZE = 50;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectAtPath(data, path) {
+  let current = [data];
+  for (const segment of path) {
+    const next = [];
+    for (const value of current) {
+      if (isRecord2(value)) {
+        const child = value[segment];
+        if (Array.isArray(child)) {
+          next.push(...child);
+        } else if (child !== null && child !== void 0) {
+          next.push(child);
+        }
+      }
+    }
+    current = next;
+  }
+  return current.filter(isRecord2);
+}
+function resolveContext(options) {
+  const env = readEnvSettings();
+  const space = options.space ?? env.space;
+  const environment = options.environment ?? env.environment ?? "master";
+  const preview = options.preview ?? false;
+  const token = options.token ?? (preview ? env.previewToken : env.token);
+  if (!space || !token) {
+    const missing = [];
+    if (!space) {
+      missing.push(
+        "space (pass `space` or set CONTENTFUL_SPACE_ID / NEXT_PUBLIC_CONTENTFUL_SPACE_ID)"
+      );
+    }
+    if (!token) {
+      missing.push(
+        preview ? "preview access token (pass `token` or set CONTENTFUL_PREVIEW_ACCESS_TOKEN / NEXT_PUBLIC_CONTENTFUL_PREVIEW_ACCESS_TOKEN)" : "access token (pass `token` or set CONTENTFUL_ACCESS_TOKEN / NEXT_PUBLIC_CONTENTFUL_ACCESS_TOKEN)"
+      );
+    }
+    throw new FetchContentfulError(
+      `Missing required Contentful configuration: ${missing.join("; ")}.`,
+      { code: "CONFIG" }
+    );
+  }
+  const retry = {
+    retries: options.retries ?? DEFAULT_RETRIES,
+    baseDelayMs: options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,
+    maxDelayMs: options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS
+  };
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const context = {
+    space,
+    environment,
+    token,
+    preview,
+    locale: options.locale,
+    fetch: fetchImpl,
+    retry,
+    autoSplitNestedCollections: options.autoSplitNestedCollections ?? true,
+    splitBatchSize: options.splitBatchSize ?? DEFAULT_SPLIT_BATCH_SIZE
+  };
+  if (options.signal) context.signal = options.signal;
+  if (options.next) context.next = options.next;
+  if (options.cache) context.cache = options.cache;
+  return context;
+}
+async function resolvePlan(plan, data, variables, context) {
+  const parents = collectAtPath(data, plan.path);
+  const relevant = parents.filter(
+    (parent) => typeof parent[TYPENAME_ALIAS] === "string" && (plan.typeCondition === void 0 || parent[TYPENAME_ALIAS] === plan.typeCondition)
+  );
+  if (relevant.length === 0) {
+    return;
+  }
+  const byType = /* @__PURE__ */ new Map();
+  for (const parent of relevant) {
+    const typename = parent[TYPENAME_ALIAS];
+    const sys = parent[SYS_ID_ALIAS];
+    if (!isRecord2(sys) || typeof sys["id"] !== "string") {
+      throw new FetchContentfulError(
+        `Cannot split "${plan.responseKey}": a parent entry is missing its sys id.`,
+        { code: "STITCH" }
+      );
+    }
+    const group = byType.get(typename) ?? [];
+    group.push(parent);
+    byType.set(typename, group);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...byType.entries()].map(async ([typename, group]) => {
+      const ids = [
+        ...new Set(
+          group.map((parent) => {
+            const sys = parent[SYS_ID_ALIAS];
+            return sys.id;
+          })
+        )
+      ];
+      await Promise.all(
+        chunk(ids, context.splitBatchSize).map(async (idBatch) => {
+          const { document, rootKey } = buildSubquery(
+            plan,
+            typename,
+            idBatch.length,
+            context
+          );
+          const subData = await executeDocument(
+            document,
+            { ...variables, _splitIds: idBatch },
+            context
+          );
+          const collection = subData[rootKey];
+          const items = isRecord2(collection) && Array.isArray(collection["items"]) ? collection["items"] : void 0;
+          if (!items) {
+            throw new FetchContentfulError(
+              `Split subquery for "${typename}" returned no "${rootKey}.items". Check that the content type follows Contentful naming conventions.`,
+              { code: "STITCH" }
+            );
+          }
+          for (const item of items) {
+            if (isRecord2(item)) {
+              const sys = item["sys"];
+              if (isRecord2(sys) && typeof sys["id"] === "string") {
+                resolved.set(`${typename}:${sys["id"]}`, item[plan.responseKey]);
+              }
+            }
+          }
+        })
+      );
+    })
+  );
+  for (const parent of relevant) {
+    const typename = parent[TYPENAME_ALIAS];
+    const sys = parent[SYS_ID_ALIAS];
+    const key = `${typename}:${sys.id}`;
+    if (!resolved.has(key)) {
+      throw new FetchContentfulError(
+        `Split subquery did not return entry "${sys.id}" of type "${typename}" for field "${plan.responseKey}".`,
+        { code: "STITCH" }
+      );
+    }
+    parent[plan.responseKey] = resolved.get(key);
+  }
+}
+function cleanupMarkers(data, plans) {
+  for (const plan of plans) {
+    for (const parent of collectAtPath(data, plan.path)) {
+      delete parent[SYS_ID_ALIAS];
+      delete parent[TYPENAME_ALIAS];
+    }
+  }
+}
+async function executeDocument(document, variables, context) {
+  const { document: outer, plans } = planSplits(document, context);
+  const data = await rawRequest(outer, variables, context);
+  await Promise.all(
+    plans.map((plan) => resolvePlan(plan, data, variables, context))
+  );
+  cleanupMarkers(data, plans);
+  return data;
+}
+function toDocument(query) {
+  if (typeof query !== "string") {
+    return query;
+  }
+  try {
+    return parse(query);
+  } catch (cause) {
+    throw new FetchContentfulError(
+      `Failed to parse GraphQL query: ${String(cause)}`,
+      { code: "CONFIG", cause }
+    );
+  }
+}
+function withAutoVariables(document, variables, context) {
+  const declared = new Set(
+    (getOperation(document).variableDefinitions ?? []).map(
+      (definition) => definition.variable.name.value
+    )
+  );
+  const merged = { ...variables };
+  if (declared.has("preview") && merged["preview"] === void 0) {
+    merged["preview"] = context.preview;
+  }
+  if (declared.has("locale") && merged["locale"] === void 0 && context.locale !== void 0) {
+    merged["locale"] = context.locale;
+  }
+  return merged;
+}
+async function fetchContentful(query, options = {}) {
+  const context = resolveContext(options);
+  let document = inlineFragments(toDocument(query));
+  if (options.autoInjectArgs ?? true) {
+    document = injectRootArgs(document, {
+      preview: context.preview,
+      locale: context.locale
+    });
+  }
+  if (options.validateLocale && context.locale !== void 0) {
+    const locales = await getLocales(context);
+    if (!locales.some((locale) => locale.code === context.locale)) {
+      throw new FetchContentfulError(
+        `Locale "${context.locale}" is not configured in space "${context.space}" (available: ${locales.map((locale) => locale.code).join(", ")}).`,
+        { code: "LOCALE" }
+      );
+    }
+  }
+  const variables = withAutoVariables(
+    document,
+    options.variables ?? {},
+    context
+  );
+  const data = await executeDocument(document, variables, context);
+  const result = options.shapeResponseData === false ? data : shapeData(data);
+  if (options.unwrapRootField === false) {
+    return result;
+  }
+  return unwrapSingleRoot(result);
+}
+function createFetchContentful(defaults = {}) {
+  function bound(query, options = {}) {
+    const merged = {
+      ...defaults,
+      ...options
+    };
+    if (merged.shapeResponseData === false) {
+      if (merged.unwrapRootField === false) {
+        return fetchContentful(query, {
+          ...merged,
+          shapeResponseData: false,
+          unwrapRootField: false
+        });
+      }
+      return fetchContentful(query, {
+        ...merged,
+        shapeResponseData: false
+      });
+    }
+    if (merged.unwrapRootField === false) {
+      return fetchContentful(query, {
+        ...merged,
+        unwrapRootField: false
+      });
+    }
+    return fetchContentful(query, merged);
+  }
+  return bound;
+}
+var index_default = fetchContentful;
+
+export { FetchContentfulError, clearLocaleCache, collectAtPath, createFetchContentful, index_default as default, fetchContentful, getLocales, injectRootArgs, inlineFragments, isFetchContentfulError, readEnvSettings, shapeData, unwrapSingleRoot };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map