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

package/dist/chunk-TBKSBXGH.js

@@ -0,0 +1,452 @@
+import {
+  PreprError
+} from "./chunk-3JLWZQ37.js";
+
+// src/core/variants/constants.ts
+var PREPR_CONTEXT_ALIAS = "_preprContext";
+var PREPR_TYPE_ALIAS = "_preprType";
+var PREPR_DEFAULT_VARIANT = "ALL_OTHER_USERS";
+
+// src/core/variants/resolve.ts
+function personalizationPaths(data) {
+  const paths = /* @__PURE__ */ new Map();
+  const walk = (value, path) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (contextOf(item)?.kind === "PERSONALIZATION") {
+          const record = item;
+          const type = record[PREPR_TYPE_ALIAS] ?? record.__typename;
+          const types = paths.get(path) ?? /* @__PURE__ */ new Set();
+          types.add(typeof type === "string" ? type : "*");
+          paths.set(path, types);
+        }
+        walk(item, path);
+      }
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    for (const [key, child] of Object.entries(value)) {
+      if (key !== PREPR_CONTEXT_ALIAS && key !== PREPR_TYPE_ALIAS)
+        walk(child, path ? `${path}.${key}` : key);
+    }
+  };
+  walk(data, "");
+  return paths;
+}
+function contextOf(item) {
+  if (!item || typeof item !== "object") return null;
+  const context = item[PREPR_CONTEXT_ALIAS];
+  const ctx = context;
+  return ctx?.kind && ctx.group_id ? ctx : null;
+}
+function decisionsFrom(data) {
+  const decisions = /* @__PURE__ */ new Map();
+  const walk = (value) => {
+    if (Array.isArray(value)) return value.forEach(walk);
+    if (!value || typeof value !== "object") return;
+    const ctx = contextOf(value);
+    if (ctx?.group_id && ctx.variant_id) {
+      const ids = decisions.get(ctx.group_id) ?? [];
+      if (!ids.includes(ctx.variant_id)) ids.push(ctx.variant_id);
+      decisions.set(ctx.group_id, ids);
+    }
+    Object.values(value).forEach(walk);
+  };
+  walk(data);
+  return decisions;
+}
+function chosenVariants(ctx, options) {
+  const decided = options.decisions?.get(ctx.group_id);
+  if (ctx.kind === "AB_TEST") {
+    return options.bucket ? [options.bucket] : decided ?? ["A"];
+  }
+  return decided ?? [PREPR_DEFAULT_VARIANT];
+}
+function resolveVariants(data, options = {}) {
+  const resolve = (value) => {
+    if (Array.isArray(value)) {
+      return value.filter((item) => {
+        const ctx = contextOf(item);
+        return !ctx || chosenVariants(ctx, options).includes(ctx.variant_id ?? "");
+      }).map(resolve);
+    }
+    if (!value || typeof value !== "object") return value;
+    const out = {};
+    for (const [key, child] of Object.entries(value)) out[key] = resolve(child);
+    return out;
+  };
+  return resolve(data);
+}
+
+// src/core/variants/schema.ts
+var PREPR_SCHEMA_QUERY = `query PreprPersonalizationSchema {
+  __schema {
+    queryType { name }
+    types {
+      name
+      possibleTypes { name }
+      fields {
+        name
+        args { name }
+        type { name ofType { name ofType { name ofType { name ofType { name } } } } }
+      }
+    }
+  }
+}`;
+function namedType(ref) {
+  let current = ref;
+  while (current && !current.name) current = current.ofType;
+  return current?.name ?? "";
+}
+function toSchemaInfo(introspection) {
+  const types = {};
+  for (const type of introspection.__schema.types) {
+    if (type.name.startsWith("__")) continue;
+    const fields = {};
+    for (const field of type.fields ?? []) {
+      fields[field.name] = {
+        type: namedType(field.type),
+        personalizable: field.args.some((arg) => arg.name === "personalize")
+      };
+    }
+    types[type.name] = {
+      fields,
+      possibleTypes: (type.possibleTypes ?? []).map((t) => t.name),
+      hasContext: "_context" in fields
+    };
+  }
+  return { queryType: introspection.__schema.queryType.name, types };
+}
+
+// src/core/graphql/document.ts
+import { print } from "graphql/language/printer.js";
+import { stripIgnoredCharacters } from "graphql/utilities/stripIgnoredCharacters.js";
+var printed = /* @__PURE__ */ new WeakMap();
+function isDocumentNode(value) {
+  return typeof value === "object" && value !== null && value.kind === "Document" && Array.isArray(value.definitions);
+}
+function invalidDocument(originalError) {
+  return new PreprError(
+    "Expected a GraphQL query string, TypedDocumentString or DocumentNode",
+    "INVALID_DOCUMENT",
+    "createPreprClient",
+    originalError
+  );
+}
+var minified = /* @__PURE__ */ new Map();
+var MINIFIED_CACHE_LIMIT = 500;
+function minify(query) {
+  const cached = minified.get(query);
+  if (cached !== void 0) return cached;
+  let result = query;
+  try {
+    result = stripIgnoredCharacters(query);
+  } catch {
+  }
+  if (minified.size < MINIFIED_CACHE_LIMIT) minified.set(query, result);
+  return result;
+}
+function resolveQuery(document) {
+  if (typeof document === "string") return minify(document);
+  if (document instanceof String) return minify(document.toString());
+  if (!isDocumentNode(document)) throw invalidDocument();
+  let query = printed.get(document);
+  if (query === void 0) {
+    try {
+      query = minify(print(document));
+    } catch (error) {
+      throw invalidDocument(error instanceof Error ? error : void 0);
+    }
+    printed.set(document, query);
+  }
+  return query;
+}
+
+// src/core/variants/ast.ts
+import { parse } from "graphql/language/parser.js";
+var name = (value) => ({ kind: "Name", value });
+function selectionSet(selections) {
+  return { kind: "SelectionSet", selections };
+}
+function contextField(withKey) {
+  const fields = ["kind", "group_id", "variant_id"];
+  if (withKey) fields.push("variant_key");
+  return {
+    kind: "Field",
+    alias: name(PREPR_CONTEXT_ALIAS),
+    name: name("_context"),
+    selectionSet: selectionSet(
+      fields.map(
+        (field) => ({ kind: "Field", name: name(field) })
+      )
+    )
+  };
+}
+function typenameField() {
+  return {
+    kind: "Field",
+    alias: name(PREPR_TYPE_ALIAS),
+    name: name("__typename")
+  };
+}
+function inlineFragment(typeName, selections) {
+  return {
+    kind: "InlineFragment",
+    typeCondition: { kind: "NamedType", name: name(typeName) },
+    selectionSet: selectionSet(selections)
+  };
+}
+function contextSelections(typeName, schema, onlyTypes, withType = true) {
+  const fields = () => withType ? [contextField(true), typenameField()] : [contextField(false)];
+  const type = schema.types[typeName];
+  if (!type) return [];
+  if (type.possibleTypes.length > 0) {
+    return type.possibleTypes.filter(
+      (member) => schema.types[member]?.hasContext && (!onlyTypes || onlyTypes.has(member))
+    ).map((member) => inlineFragment(member, fields()));
+  }
+  return type.hasContext ? fields() : [];
+}
+function withoutPersonalizeArg(args = []) {
+  return args.filter((arg) => arg.name.value !== "personalize");
+}
+function documentOf(document) {
+  if (typeof document === "string") return parse(document);
+  if (document instanceof String) return parse(document.toString());
+  return document;
+}
+function collectVariables(node, used) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) collectVariables(item, used);
+    return;
+  }
+  const value = node;
+  if (value.kind === "Variable") {
+    used.add(value.name.value);
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    if (key !== "loc") collectVariables(value[key], used);
+  }
+}
+
+// src/core/variants/decision-document.ts
+function decisionSelectionSet(set, typeName, path, ctx) {
+  const selections = [];
+  for (const selection of set.selections) {
+    if (selection.kind === "FragmentSpread") {
+      const fragment = ctx.fragments[selection.name.value];
+      if (!fragment) continue;
+      const pruned = decisionSelectionSet(
+        fragment.selectionSet,
+        fragment.typeCondition.name.value,
+        path,
+        ctx
+      );
+      if (pruned) {
+        selections.push(
+          inlineFragment(fragment.typeCondition.name.value, [
+            ...pruned.selections
+          ])
+        );
+      }
+      continue;
+    }
+    if (selection.kind === "InlineFragment") {
+      const pruned = decisionSelectionSet(
+        selection.selectionSet,
+        selection.typeCondition?.name.value ?? typeName,
+        path,
+        ctx
+      );
+      if (pruned) selections.push({ ...selection, selectionSet: pruned });
+      continue;
+    }
+    if (!selection.selectionSet) continue;
+    const field = ctx.schema.types[typeName]?.fields[selection.name.value];
+    if (!field) continue;
+    const key = selection.alias?.value ?? selection.name.value;
+    const fieldPath = path ? `${path}.${key}` : key;
+    if (ctx.paths && !ctx.paths.prefixes.has(fieldPath)) continue;
+    const child = decisionSelectionSet(
+      selection.selectionSet,
+      field.type,
+      fieldPath,
+      ctx
+    );
+    const groupTypes = ctx.paths?.groups.get(fieldPath);
+    const holdsGroups = field.personalizable && (!ctx.paths || groupTypes !== void 0);
+    if (holdsGroups) {
+      selections.push({
+        ...selection,
+        arguments: withoutPersonalizeArg(selection.arguments),
+        selectionSet: selectionSet([
+          ...ctx.topLevelOnly ? [] : child?.selections ?? [],
+          ...contextSelections(
+            field.type,
+            ctx.schema,
+            groupTypes && !groupTypes.has("*") ? groupTypes : void 0,
+            false
+          )
+        ])
+      });
+    } else if (child) {
+      selections.push({
+        ...selection,
+        arguments: field.personalizable ? withoutPersonalizeArg(selection.arguments) : selection.arguments,
+        selectionSet: child
+      });
+    }
+  }
+  return selections.length > 0 ? selectionSet(selections) : null;
+}
+function toDecisionDocument(document, schema, groupPaths, options) {
+  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;
+  let paths;
+  if (groupPaths) {
+    const prefixes = /* @__PURE__ */ new Set();
+    for (const groupPath of groupPaths.keys()) {
+      const parts = groupPath.split(".");
+      for (let i = 1; i <= parts.length; i++) {
+        prefixes.add(parts.slice(0, i).join("."));
+      }
+    }
+    paths = { groups: groupPaths, prefixes };
+  }
+  const pruned = decisionSelectionSet(
+    operation.selectionSet,
+    schema.queryType,
+    "",
+    { schema, fragments, paths, topLevelOnly: options?.topLevelOnly }
+  );
+  if (!pruned) return null;
+  const used = /* @__PURE__ */ new Set();
+  collectVariables(pruned, used);
+  collectVariables(operation.directives, used);
+  return {
+    kind: "Document",
+    definitions: [
+      {
+        ...operation,
+        name: operation.name && name(`${operation.name.value}Decision`),
+        variableDefinitions: (operation.variableDefinitions ?? []).filter(
+          (definition) => used.has(definition.variable.name.value)
+        ),
+        selectionSet: pruned
+      }
+    ]
+  };
+}
+
+// src/core/variants/variants-document.ts
+function variantsSelectionSet(set, typeName, schema) {
+  const selections = set.selections.map((selection) => {
+    if (selection.kind === "InlineFragment") {
+      return {
+        ...selection,
+        selectionSet: variantsSelectionSet(
+          selection.selectionSet,
+          selection.typeCondition?.name.value ?? typeName,
+          schema
+        )
+      };
+    }
+    if (selection.kind !== "Field" || !selection.selectionSet) return selection;
+    const field = schema.types[typeName]?.fields[selection.name.value];
+    if (!field) return selection;
+    const child = variantsSelectionSet(
+      selection.selectionSet,
+      field.type,
+      schema
+    );
+    if (!field.personalizable) return { ...selection, selectionSet: child };
+    return {
+      ...selection,
+      arguments: [
+        ...withoutPersonalizeArg(selection.arguments),
+        {
+          kind: "Argument",
+          name: name("personalize"),
+          value: { kind: "BooleanValue", value: false }
+        }
+      ],
+      selectionSet: selectionSet([
+        ...child.selections,
+        ...contextSelections(field.type, schema)
+      ])
+    };
+  });
+  return { ...set, selections };
+}
+function toVariantsDocument(document, schema) {
+  const doc = documentOf(document);
+  return {
+    ...doc,
+    definitions: doc.definitions.map((definition) => {
+      if (definition.kind === "OperationDefinition") {
+        return {
+          ...definition,
+          selectionSet: variantsSelectionSet(
+            definition.selectionSet,
+            schema.queryType,
+            schema
+          )
+        };
+      }
+      if (definition.kind === "FragmentDefinition") {
+        return {
+          ...definition,
+          selectionSet: variantsSelectionSet(
+            definition.selectionSet,
+            definition.typeCondition.name.value,
+            schema
+          )
+        };
+      }
+      return definition;
+    })
+  };
+}
+
+// src/core/variants/queries.ts
+function toVariantsQuery(document, schema) {
+  return resolveQuery(toVariantsDocument(document, schema));
+}
+function toDecisionQuery(document, schema, options = {}) {
+  const paths = options.from === void 0 ? void 0 : personalizationPaths(options.from);
+  if (paths && paths.size === 0) return null;
+  const decision = toDecisionDocument(document, schema, paths, {
+    topLevelOnly: !paths && options.topLevelOnly
+  });
+  return decision ? resolveQuery(decision) : null;
+}
+
+export {
+  PREPR_DEFAULT_VARIANT,
+  name,
+  selectionSet,
+  documentOf,
+  collectVariables,
+  toDecisionDocument,
+  personalizationPaths,
+  contextOf,
+  decisionsFrom,
+  resolveVariants,
+  PREPR_SCHEMA_QUERY,
+  toSchemaInfo,
+  toVariantsDocument,
+  resolveQuery,
+  toVariantsQuery,
+  toDecisionQuery
+};