@preprio/toolkit 0.5.0-rc.2 → 0.6.0-alpha.1

package/dist/graphql.js

@@ -0,0 +1,419 @@
+import {
+  isPersonalizedResponse
+} from "./chunk-3NCEVJJ3.js";
+import {
+  stegaClean
+} from "./chunk-S5RWVMDJ.js";
+import {
+  PREPR_DEFAULT_VARIANT,
+  PREPR_SCHEMA_QUERY,
+  collectVariables,
+  contextOf,
+  decisionsFrom,
+  documentOf,
+  name,
+  personalizationPaths,
+  resolveQuery,
+  resolveVariants,
+  selectionSet,
+  toDecisionDocument,
+  toDecisionQuery,
+  toSchemaInfo,
+  toVariantsDocument,
+  toVariantsQuery
+} from "./chunk-TBKSBXGH.js";
+import {
+  PreprError,
+  validatePreprToken
+} from "./chunk-3JLWZQ37.js";
+import "./chunk-YWIKKWBR.js";
+
+// src/core/variants/probe-document.ts
+function probeSelectionSet(set, fragments) {
+  const selections = [
+    { kind: "Field", name: name("__typename") }
+  ];
+  for (const selection of set.selections) {
+    if (selection.kind === "Field") {
+      if (!selection.selectionSet) continue;
+      selections.push({
+        ...selection,
+        selectionSet: probeSelectionSet(selection.selectionSet, fragments)
+      });
+      continue;
+    }
+    const fragment = selection.kind === "InlineFragment" ? selection : fragments[selection.name.value];
+    if (!fragment) continue;
+    const child = probeSelectionSet(fragment.selectionSet, fragments);
+    if (child.selections.length === 1) continue;
+    selections.push({
+      kind: "InlineFragment",
+      typeCondition: fragment.typeCondition,
+      directives: selection.directives,
+      selectionSet: child
+    });
+  }
+  return selectionSet(selections);
+}
+function toAbProbeDocument(document) {
+  const doc = documentOf(document);
+  const fragments = {};
+  for (const definition of doc.definitions) {
+    if (definition.kind === "FragmentDefinition") {
+      fragments[definition.name.value] = definition;
+    }
+  }
+  const operation = doc.definitions.find(
+    (definition) => definition.kind === "OperationDefinition"
+  );
+  if (!operation) return null;
+  const probe = probeSelectionSet(operation.selectionSet, fragments);
+  const used = /* @__PURE__ */ new Set();
+  collectVariables(probe, used);
+  collectVariables(operation.directives, used);
+  return {
+    kind: "Document",
+    definitions: [
+      {
+        ...operation,
+        name: operation.name && name(`${operation.name.value}AbCheck`),
+        variableDefinitions: (operation.variableDefinitions ?? []).filter(
+          (definition) => used.has(definition.variable.name.value)
+        ),
+        selectionSet: probe
+      }
+    ]
+  };
+}
+
+// src/core/variants/stack.ts
+function containsKind(value, kind) {
+  if (Array.isArray(value))
+    return value.some((item) => containsKind(item, kind));
+  if (!value || typeof value !== "object") return false;
+  if (contextOf(value)?.kind === kind) return true;
+  return Object.values(value).some((child) => containsKind(child, kind));
+}
+function splitStack(items) {
+  const blocks = [];
+  let position = 0;
+  const positionsOf = (block) => block.key.startsWith("group:") ? 1 : block.items.length;
+  items.forEach((item, index) => {
+    const ctx = contextOf(item);
+    const groupKey = ctx ? `group:${ctx.group_id}` : null;
+    const personalized = containsKind(item, "PERSONALIZATION");
+    const abTest = containsKind(item, "AB_TEST");
+    const last = blocks.at(-1);
+    const plain = !groupKey && !personalized && !abTest;
+    if (groupKey && last?.key === groupKey) {
+      last.personalized || (last.personalized = personalized);
+      last.abTest || (last.abTest = abTest);
+      last.items.push(item);
+    } else if (plain && last && !last.personalized && !last.abTest) {
+      last.items.push(item);
+    } else {
+      const last2 = blocks.at(-1);
+      if (last2) position = last2.index + positionsOf(last2);
+      blocks.push({
+        key: groupKey ?? `items:${index}`,
+        items: [item],
+        index: position,
+        personalized,
+        abTest
+      });
+    }
+  });
+  return blocks;
+}
+
+// src/core/variants/tracking.ts
+function preprVariantProps(item) {
+  const key = contextOf(item)?.variant_key;
+  return key ? { "data-prepr-variant-key": key } : {};
+}
+
+// src/core/graphql/transport.ts
+import { VERCEL_STEGA_REGEX } from "@vercel/stega";
+var OPERATION_NAME = /\b(?:query|mutation|subscription)\s+([_A-Za-z][_0-9A-Za-z]*)/;
+var STEGA_RAW = new RegExp(
+  VERCEL_STEGA_REGEX.source,
+  VERCEL_STEGA_REGEX.flags.replace("g", "")
+);
+var STEGA_ESCAPED = /\\u(?:200[bcd]|206[0-3]|feff|d834)/i;
+var URL_KEY = /(url|slug|link|href)$/i;
+var FASTLY_QUERY_MAX = 96 * 1024;
+function base64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary);
+}
+function cacheInit(init, noStore) {
+  const result = { ...init };
+  if (noStore) {
+    result.cache = "no-store";
+    delete result.next;
+  }
+  return result;
+}
+function isFrameworkSignal(error) {
+  return typeof error === "object" && error !== null && typeof error.digest === "string";
+}
+function cleanEveryString(_key, value) {
+  return typeof value === "string" ? stegaClean(value) : value;
+}
+function cleanUrlStrings(key, value) {
+  return typeof value === "string" && URL_KEY.test(key) ? stegaClean(value) : value;
+}
+function parseBody(text, stega) {
+  if (stega === "none" || !(STEGA_RAW.test(text) || STEGA_ESCAPED.test(text))) {
+    return JSON.parse(text);
+  }
+  return JSON.parse(text, stega === "all" ? cleanEveryString : cleanUrlStrings);
+}
+function createTransport(options) {
+  const { url, preview = false } = options;
+  const stega = options.stega ?? (preview ? "urls" : "all");
+  const clientHeaders = new Headers(options.headers);
+  return async (document, variables, queryOptions = {}) => {
+    const query = resolveQuery(document);
+    const operation = OPERATION_NAME.exec(query)?.[1] ?? "anonymous";
+    const headers = new Headers(clientHeaders);
+    for (const layer of [queryOptions.init?.headers, queryOptions.headers]) {
+      new Headers(layer).forEach((value, key) => {
+        headers.set(key, value);
+      });
+    }
+    headers.set("Content-Type", "application/json");
+    const perRequestHeaders = queryOptions.headers !== void 0 || queryOptions.init?.headers !== void 0;
+    const payload = JSON.stringify({ query, variables });
+    const fastly = options.fastlyQuery ? base64(payload) : null;
+    const viaGet = fastly !== null && fastly.length <= FASTLY_QUERY_MAX;
+    if (viaGet) headers.set("Fastly-Query", fastly);
+    const init = {
+      ...cacheInit(queryOptions.init, preview || perRequestHeaders),
+      method: viaGet ? "GET" : "POST",
+      headers,
+      body: viaGet ? void 0 : payload
+    };
+    const fetchImpl = queryOptions.fetch ?? options.fetch;
+    let response;
+    try {
+      response = await (fetchImpl ? fetchImpl(url, init) : fetch(url, init));
+    } catch (error) {
+      if (isFrameworkSignal(error)) throw error;
+      throw new PreprError(
+        `Prepr GraphQL request failed for ${operation}`,
+        "FETCH_ERROR",
+        operation,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (!response.ok) {
+      throw new PreprError(
+        `Prepr GraphQL HTTP ${response.status} for ${operation}${response.status === 412 ? " (Prepr rejects queries longer than 27,500 characters)" : ""}`,
+        "HTTP_ERROR",
+        operation
+      );
+    }
+    let body;
+    try {
+      body = parseBody(await response.text(), stega);
+    } catch (error) {
+      throw new PreprError(
+        `Prepr GraphQL response for ${operation} is not valid JSON`,
+        "INVALID_RESPONSE",
+        operation,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (typeof body !== "object" || body === null) {
+      throw new PreprError(
+        `Prepr GraphQL response for ${operation} is not an object`,
+        "INVALID_RESPONSE",
+        operation
+      );
+    }
+    const { data, errors } = body;
+    if (Array.isArray(errors) && errors.length > 0) {
+      const messages = errors.map((e) => String(e?.message ?? "Unknown error")).join("; ");
+      throw new PreprError(
+        `Prepr GraphQL errors for ${operation}: ${messages}`,
+        "GRAPHQL_ERROR",
+        operation
+      );
+    }
+    if (data === null || data === void 0) {
+      throw new PreprError(
+        `Prepr GraphQL response for ${operation} has no data`,
+        "INVALID_RESPONSE",
+        operation
+      );
+    }
+    return { data, personalized: isPersonalizedResponse(response) };
+  };
+}
+
+// src/core/graphql/probe.ts
+var AB_TEST_VARY = /\bPrepr-ABTesting/i;
+var SEGMENTS_VARY = /\bPrepr-Segments/i;
+var AB_CHECK_TTL_MS = 6e4;
+var AB_CHECK_MAX_ENTRIES = 1e3;
+function createVaryProbe(run, options) {
+  const abProbes = /* @__PURE__ */ new Map();
+  const abChecks = /* @__PURE__ */ new Map();
+  return (document, variables) => {
+    const key = JSON.stringify(variables ?? null);
+    let answers = abChecks.get(document);
+    if (!answers) {
+      answers = /* @__PURE__ */ new Map();
+      abChecks.set(document, answers);
+    }
+    const cached = answers.get(key);
+    if (cached && Date.now() - cached.at < AB_CHECK_TTL_MS) return cached.value;
+    const value = (async () => {
+      let probe = abProbes.get(document);
+      if (probe === void 0) {
+        probe = toAbProbeDocument(document);
+        abProbes.set(document, probe);
+      }
+      if (!probe) return "";
+      let vary = "";
+      const send = options.fetch ?? fetch;
+      await run(probe, variables, {
+        fetch: async (input, init) => {
+          const response = await send(input, init);
+          vary = response.headers.get("vary") ?? "";
+          return response;
+        }
+      });
+      return vary;
+    })().catch((error) => {
+      if (isFrameworkSignal(error)) throw error;
+      answers.delete(key);
+      return null;
+    });
+    if (answers.size >= AB_CHECK_MAX_ENTRIES) {
+      answers.delete(answers.keys().next().value);
+    }
+    answers.set(key, { value, at: Date.now() });
+    return value;
+  };
+}
+
+// src/core/graphql/client.ts
+function isParseableUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertPreprUrl(url, source) {
+  validatePreprToken(url);
+  if (!isParseableUrl(url)) {
+    throw new PreprError(
+      "Prepr GraphQL URL is not a valid URL",
+      "INVALID_TOKEN",
+      source
+    );
+  }
+}
+function createPreprClient(options) {
+  assertPreprUrl(options.url, "createPreprClient");
+  const run = createTransport(options);
+  const probeVary = createVaryProbe(run, options);
+  let schema;
+  const loadSchema = () => schema ?? (schema = run(
+    PREPR_SCHEMA_QUERY,
+    void 0,
+    { init: options.schemaInit }
+  ).then(
+    (result) => toSchemaInfo(result.data),
+    (error) => {
+      schema = void 0;
+      throw error;
+    }
+  ));
+  const variantsDocuments = /* @__PURE__ */ new Map();
+  const decisionDocuments = /* @__PURE__ */ new Map();
+  return {
+    async query(document, variables, queryOptions = {}) {
+      const { variants, ...rest } = queryOptions;
+      if (!variants) return run(document, variables, rest);
+      let derived = variantsDocuments.get(document);
+      if (!derived) {
+        derived = toVariantsDocument(document, await loadSchema());
+        variantsDocuments.set(document, derived);
+      }
+      return run(derived, variables, rest);
+    },
+    async decide(document, variables, queryOptions = {}) {
+      const { from, topLevelOnly, ...rest } = queryOptions;
+      const paths = from === void 0 ? void 0 : personalizationPaths(from);
+      if (paths && paths.size === 0) return /* @__PURE__ */ new Map();
+      const signature = paths ? [...paths].map(([path, types]) => `${path}:${[...types].sort().join(",")}`).sort().join("|") : topLevelOnly ? "top" : "*";
+      let byPaths = decisionDocuments.get(document);
+      if (!byPaths) {
+        byPaths = /* @__PURE__ */ new Map();
+        decisionDocuments.set(document, byPaths);
+      }
+      let derived = byPaths.get(signature);
+      if (derived === void 0) {
+        derived = toDecisionDocument(document, await loadSchema(), paths, {
+          topLevelOnly: !paths && topLevelOnly
+        });
+        byPaths.set(signature, derived);
+      }
+      if (!derived) return /* @__PURE__ */ new Map();
+      const { data } = await run(derived, variables, rest);
+      return decisionsFrom(data);
+    },
+    hasAbTests: (document, variables) => probeVary(document, variables).then(
+      (vary) => vary === null || AB_TEST_VARY.test(vary)
+    ),
+    hasSegments: (document, variables) => probeVary(document, variables).then(
+      (vary) => vary === null || SEGMENTS_VARY.test(vary)
+    )
+  };
+}
+
+// src/core/graphql/schema-loader.ts
+var schemas = /* @__PURE__ */ new Map();
+async function loadPreprSchema(url, options = {}) {
+  assertPreprUrl(url, "loadPreprSchema");
+  let schema = schemas.get(url);
+  if (!schema) {
+    const run = createTransport({ url, fetch: options.fetch, stega: "none" });
+    schema = run(
+      PREPR_SCHEMA_QUERY
+    ).then((result) => toSchemaInfo(result.data)).catch((error) => {
+      schemas.delete(url);
+      if (error instanceof PreprError) throw error;
+      throw new PreprError(
+        "Prepr schema response is not an introspection result",
+        "INVALID_RESPONSE",
+        "loadPreprSchema",
+        error instanceof Error ? error : void 0
+      );
+    });
+    schemas.set(url, schema);
+  }
+  return schema;
+}
+export {
+  PREPR_DEFAULT_VARIANT,
+  PreprError,
+  createPreprClient,
+  decisionsFrom,
+  isPersonalizedResponse,
+  loadPreprSchema,
+  preprVariantProps,
+  resolveVariants,
+  splitStack,
+  toDecisionQuery,
+  toVariantsQuery
+};