@preprio/toolkit 0.6.0-alpha.0 → 0.6.0-alpha.10

package/dist/graphql/codegen.cjs

@@ -0,0 +1,557 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/codegen/index.ts
+var codegen_exports = {};
+__export(codegen_exports, {
+  plugin: () => plugin
+});
+module.exports = __toCommonJS(codegen_exports);
+
+// src/core/graphql/document.ts
+var import_printer = require("graphql/language/printer.js");
+var import_stripIgnoredCharacters = require("graphql/utilities/stripIgnoredCharacters.js");
+
+// src/core/server.ts
+var PreprError = class extends Error {
+  constructor(message, code, context, originalError) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.originalError = originalError;
+    this.name = "PreprError";
+  }
+};
+
+// src/core/graphql/document.ts
+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 = (0, import_stripIgnoredCharacters.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((0, import_printer.print)(document));
+    } catch (error) {
+      throw invalidDocument(error instanceof Error ? error : void 0);
+    }
+    printed.set(document, query);
+  }
+  return query;
+}
+
+// src/core/variants/ast.ts
+var import_parser = require("graphql/language/parser.js");
+
+// src/core/variants/constants.ts
+var PREPR_CONTEXT_ALIAS = "_preprContext";
+var PREPR_TYPE_ALIAS = "_preprType";
+
+// src/core/variants/ast.ts
+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 (0, import_parser.parse)(document);
+  if (document instanceof String) return (0, import_parser.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) continue;
+      if (fragment.typeCondition.name.value === typeName) {
+        selections.push(...pruned.selections);
+      } else {
+        selections.push(
+          inlineFragment(fragment.typeCondition.name.value, [
+            ...pruned.selections
+          ])
+        );
+      }
+      continue;
+    }
+    if (selection.kind === "InlineFragment") {
+      const condition = selection.typeCondition?.name.value ?? typeName;
+      const pruned = decisionSelectionSet(
+        selection.selectionSet,
+        condition,
+        path,
+        ctx
+      );
+      if (!pruned) continue;
+      if (condition === typeName && !selection.directives?.length) {
+        selections.push(...pruned.selections);
+      } else {
+        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);
+  const shared = sharedContextFragment(schema);
+  return {
+    kind: "Document",
+    definitions: [
+      ...shared ? [shared.definition] : [],
+      {
+        ...operation,
+        name: operation.name && name(`${operation.name.value}Decision`),
+        variableDefinitions: (operation.variableDefinitions ?? []).filter(
+          (definition) => used.has(definition.variable.name.value)
+        ),
+        selectionSet: shared ? shared.apply(pruned) : pruned
+      }
+    ]
+  };
+}
+function sharedContextFragment(schema) {
+  const contextTypes = new Set(
+    Object.values(schema.types).flatMap(
+      (type) => type.hasContext ? [type.fields._context.type] : []
+    )
+  );
+  if (contextTypes.size !== 1) return null;
+  const [contextType] = contextTypes;
+  const fragmentName = "c";
+  const definition = {
+    kind: "FragmentDefinition",
+    name: name(fragmentName),
+    typeCondition: { kind: "NamedType", name: name(contextType) },
+    selectionSet: selectionSet(
+      ["kind", "group_id", "variant_id"].map(
+        (field) => ({ kind: "Field", name: name(field) })
+      )
+    )
+  };
+  const spread = {
+    kind: "FragmentSpread",
+    name: name(fragmentName)
+  };
+  const apply = (set) => selectionSet(
+    set.selections.map((selection) => {
+      if (selection.kind === "Field" && selection.alias?.value === PREPR_CONTEXT_ALIAS) {
+        return { ...selection, selectionSet: selectionSet([spread]) };
+      }
+      return "selectionSet" in selection && selection.selectionSet ? {
+        ...selection,
+        selectionSet: apply(selection.selectionSet)
+      } : selection;
+    })
+  );
+  return { definition, apply };
+}
+
+// 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;
+}
+
+// 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;
+}
+
+// src/core/variants/schema.ts
+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/codegen/index.ts
+function typeRef(type) {
+  const value = type;
+  return value.ofType ? { name: null, ofType: typeRef(value.ofType) } : { name: value.name ?? null };
+}
+function introspect(schema) {
+  const types = Object.values(
+    schema.getTypeMap()
+  ).map((type) => {
+    const possible = "getTypes" in type || "getInterfaces" in type ? schema.getPossibleTypes(type) : [];
+    return {
+      name: type.name,
+      possibleTypes: possible.length ? possible.map((member) => ({ name: member.name })) : null,
+      fields: type.getFields ? Object.values(type.getFields()).map((field) => ({
+        name: field.name,
+        args: (field.args ?? []).map((arg) => ({ name: arg.name })),
+        type: typeRef(field.type)
+      })) : null
+    };
+  });
+  return {
+    __schema: {
+      queryType: { name: schema.getQueryType()?.name ?? "Query" },
+      types
+    }
+  };
+}
+function spreadNames(node, into) {
+  if (Array.isArray(node)) {
+    for (const child of node) spreadNames(child, into);
+  } else if (node && typeof node === "object") {
+    const value = node;
+    if (value.kind === "FragmentSpread" && value.name) {
+      into.add(value.name.value);
+    }
+    for (const [key, child] of Object.entries(node)) {
+      if (key !== "loc") spreadNames(child, into);
+    }
+  }
+  return into;
+}
+function plugin(schema, documents, _config) {
+  const info = toSchemaInfo(introspect(schema));
+  const definitions = documents.flatMap((source) => [
+    ...source.document?.definitions ?? []
+  ]);
+  const fragments = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    if (definition.kind === "FragmentDefinition") {
+      fragments.set(definition.name.value, definition);
+    }
+  }
+  const lines = [
+    "// Generated by @preprio/toolkit/graphql/codegen. Do not edit."
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    if (definition.kind !== "OperationDefinition") continue;
+    const operation = definition;
+    if (operation.operation !== "query" || !operation.name) continue;
+    const name2 = operation.name.value;
+    if (seen.has(name2)) {
+      throw new Error(
+        `@preprio/toolkit codegen: two queries are named "${name2}"; rename one so their exports do not collide.`
+      );
+    }
+    seen.add(name2);
+    const used = /* @__PURE__ */ new Set();
+    const queue = [...spreadNames(operation, /* @__PURE__ */ new Set())];
+    while (queue.length) {
+      const next = queue.pop();
+      if (used.has(next) || !fragments.has(next)) continue;
+      used.add(next);
+      queue.push(...spreadNames(fragments.get(next), /* @__PURE__ */ new Set()));
+    }
+    const document = {
+      kind: "Document",
+      definitions: [operation, ...[...used].map((n) => fragments.get(n))]
+    };
+    const decision = toDecisionQuery(document, info);
+    if (!decision) continue;
+    lines.push(
+      `export const ${name2}VariantsQuery = ${JSON.stringify(toVariantsQuery(document, info))};`,
+      `export const ${name2}DecisionQuery = ${JSON.stringify(decision)};`
+    );
+  }
+  return lines.join("\n") + "\n";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  plugin
+});

package/dist/graphql/codegen.d.cts

@@ -0,0 +1,23 @@
+import { GraphQLSchema, DocumentNode } from 'graphql';
+
+/**
+ * graphql-codegen plugin: for every named query that touches personalizable
+ * fields, writes the variants query and the decision query as string
+ * constants, `<Name>VariantsQuery` and `<Name>DecisionQuery`. For sites that
+ * send queries with their own client and want the rewrites done at build
+ * time instead of loading the schema at runtime.
+ *
+ * The decision query asks about every personalizable list of the query. When
+ * the variants result is at hand at runtime, `toDecisionQuery(query, schema,
+ * { from })` is smaller and faster for visitors Prepr has not seen before.
+ *
+ * Register it in codegen.ts: `plugins: ['@preprio/toolkit/graphql/codegen']`.
+ *
+ * @throws Error when two queries share a name, since their exports would
+ *   collide.
+ */
+declare function plugin(schema: GraphQLSchema, documents: {
+    document?: DocumentNode;
+}[], _config?: Record<string, never>): string;
+
+export { plugin };

package/dist/graphql/codegen.d.ts

@@ -0,0 +1,23 @@
+import { GraphQLSchema, DocumentNode } from 'graphql';
+
+/**
+ * graphql-codegen plugin: for every named query that touches personalizable
+ * fields, writes the variants query and the decision query as string
+ * constants, `<Name>VariantsQuery` and `<Name>DecisionQuery`. For sites that
+ * send queries with their own client and want the rewrites done at build
+ * time instead of loading the schema at runtime.
+ *
+ * The decision query asks about every personalizable list of the query. When
+ * the variants result is at hand at runtime, `toDecisionQuery(query, schema,
+ * { from })` is smaller and faster for visitors Prepr has not seen before.
+ *
+ * Register it in codegen.ts: `plugins: ['@preprio/toolkit/graphql/codegen']`.
+ *
+ * @throws Error when two queries share a name, since their exports would
+ *   collide.
+ */
+declare function plugin(schema: GraphQLSchema, documents: {
+    document?: DocumentNode;
+}[], _config?: Record<string, never>): string;
+
+export { plugin };

package/dist/graphql/codegen.js

@@ -0,0 +1,99 @@
+import {
+  toDecisionQuery,
+  toSchemaInfo,
+  toVariantsQuery
+} from "../chunk-M3RBYJ5J.js";
+import "../chunk-SF6TN4JR.js";
+import "../chunk-TN6SNAR2.js";
+
+// src/codegen/index.ts
+function typeRef(type) {
+  const value = type;
+  return value.ofType ? { name: null, ofType: typeRef(value.ofType) } : { name: value.name ?? null };
+}
+function introspect(schema) {
+  const types = Object.values(
+    schema.getTypeMap()
+  ).map((type) => {
+    const possible = "getTypes" in type || "getInterfaces" in type ? schema.getPossibleTypes(type) : [];
+    return {
+      name: type.name,
+      possibleTypes: possible.length ? possible.map((member) => ({ name: member.name })) : null,
+      fields: type.getFields ? Object.values(type.getFields()).map((field) => ({
+        name: field.name,
+        args: (field.args ?? []).map((arg) => ({ name: arg.name })),
+        type: typeRef(field.type)
+      })) : null
+    };
+  });
+  return {
+    __schema: {
+      queryType: { name: schema.getQueryType()?.name ?? "Query" },
+      types
+    }
+  };
+}
+function spreadNames(node, into) {
+  if (Array.isArray(node)) {
+    for (const child of node) spreadNames(child, into);
+  } else if (node && typeof node === "object") {
+    const value = node;
+    if (value.kind === "FragmentSpread" && value.name) {
+      into.add(value.name.value);
+    }
+    for (const [key, child] of Object.entries(node)) {
+      if (key !== "loc") spreadNames(child, into);
+    }
+  }
+  return into;
+}
+function plugin(schema, documents, _config) {
+  const info = toSchemaInfo(introspect(schema));
+  const definitions = documents.flatMap((source) => [
+    ...source.document?.definitions ?? []
+  ]);
+  const fragments = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    if (definition.kind === "FragmentDefinition") {
+      fragments.set(definition.name.value, definition);
+    }
+  }
+  const lines = [
+    "// Generated by @preprio/toolkit/graphql/codegen. Do not edit."
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    if (definition.kind !== "OperationDefinition") continue;
+    const operation = definition;
+    if (operation.operation !== "query" || !operation.name) continue;
+    const name = operation.name.value;
+    if (seen.has(name)) {
+      throw new Error(
+        `@preprio/toolkit codegen: two queries are named "${name}"; rename one so their exports do not collide.`
+      );
+    }
+    seen.add(name);
+    const used = /* @__PURE__ */ new Set();
+    const queue = [...spreadNames(operation, /* @__PURE__ */ new Set())];
+    while (queue.length) {
+      const next = queue.pop();
+      if (used.has(next) || !fragments.has(next)) continue;
+      used.add(next);
+      queue.push(...spreadNames(fragments.get(next), /* @__PURE__ */ new Set()));
+    }
+    const document = {
+      kind: "Document",
+      definitions: [operation, ...[...used].map((n) => fragments.get(n))]
+    };
+    const decision = toDecisionQuery(document, info);
+    if (!decision) continue;
+    lines.push(
+      `export const ${name}VariantsQuery = ${JSON.stringify(toVariantsQuery(document, info))};`,
+      `export const ${name}DecisionQuery = ${JSON.stringify(decision)};`
+    );
+  }
+  return lines.join("\n") + "\n";
+}
+export {
+  plugin
+};