@conduit-client/graphql-normalization 5.67.0-dev1

package/dist/v1/index.js

@@ -0,0 +1,1638 @@
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { buildReadWriteResult, extractReadWriteData, IdentifiableTypeRepository } from "@conduit-client/type-normalization/v1";
+import { err, ok, stableJSONStringify, ObjectPrototypeHasOwnProperty, deepEquals } from "@conduit-client/utils";
+import { Kind, visit } from "@conduit-client/onestore-graphql-parser/v1";
+function extractValue(valueNode, variableDefinitions, expectedType) {
+  if (valueNode.kind === Kind.VARIABLE) {
+    const variableResult = extractVariableValue(valueNode.name.value, variableDefinitions);
+    if (variableResult.isErr()) {
+      return variableResult;
+    }
+    return validateExpectedType(variableResult.value, expectedType);
+  } else if (valueNode.kind === Kind.NULL) {
+    return validateExpectedType(null, expectedType);
+  } else if (valueNode.kind === Kind.LIST) {
+    const values = [];
+    for (const val of valueNode.values) {
+      const extractedResult = extractValue(val, variableDefinitions);
+      if (extractedResult.isErr()) {
+        return extractedResult;
+      }
+      values.push(extractedResult.value);
+    }
+    return validateExpectedType(values, expectedType);
+  } else if (valueNode.kind === Kind.OBJECT) {
+    const value = {};
+    for (const field of valueNode.fields) {
+      const extractedResult = extractValue(field.value, variableDefinitions);
+      if (extractedResult.isErr()) {
+        return extractedResult;
+      }
+      value[field.name.value] = extractedResult.value;
+    }
+    return validateExpectedType(value, expectedType);
+  } else if (valueNode.kind === Kind.INT) {
+    const value = parseInt(valueNode.value, 10);
+    return validateExpectedType(value, expectedType);
+  } else if (valueNode.kind === Kind.FLOAT) {
+    const value = parseFloat(valueNode.value);
+    return validateExpectedType(value, expectedType);
+  } else {
+    const value = valueNode.value;
+    return validateExpectedType(value, expectedType);
+  }
+}
+function extractVariableValue(variableName, variableDefinitions) {
+  const variable = variableDefinitions[variableName];
+  if (!variable) {
+    return err(
+      new Error(`Variable '${variableName}' was used in the query but was not defined`)
+    );
+  }
+  if (variable.value !== void 0) {
+    return ok(variable.value);
+  }
+  if (variable.definition.defaultValue) {
+    return extractValue(variable.definition.defaultValue, variableDefinitions);
+  }
+  return ok(void 0);
+}
+function validateExpectedType(value, expectedType) {
+  if (!expectedType) {
+    return ok(value);
+  }
+  if (value === null) {
+    if (expectedType.nullable) {
+      return ok(value);
+    } else {
+      return err(new Error(`Expected ${expectedType.type}, but got null`));
+    }
+  }
+  const actualType = typeof value;
+  if (actualType === expectedType.type) {
+    return ok(value);
+  }
+  const expectedTypeString = expectedType.nullable ? `${expectedType.type} | null` : expectedType.type;
+  return err(
+    new Error(`Expected ${expectedTypeString}, but got ${actualType}: ${JSON.stringify(value)}`)
+  );
+}
+function deepMerge(target, ...sources) {
+  for (const source of sources) {
+    for (const key in source) {
+      if (ObjectPrototypeHasOwnProperty.call(source, key)) {
+        const targetValue = target[key];
+        const sourceValue = source[key];
+        if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+          const length = sourceValue.length;
+          target[key] = Array.from({ length }, (_, index) => {
+            const targetItem = targetValue[index];
+            const sourceItem = sourceValue[index];
+            if (targetItem === void 0) {
+              return sourceItem;
+            } else if (sourceItem === void 0) {
+              return targetItem;
+            } else if (targetItem instanceof Object && !Array.isArray(targetItem) && sourceItem instanceof Object && !Array.isArray(sourceItem)) {
+              return deepMerge({}, targetItem, sourceItem);
+            } else {
+              return sourceItem;
+            }
+          });
+        } else if (targetValue instanceof Object && !Array.isArray(targetValue) && sourceValue instanceof Object && !Array.isArray(sourceValue)) {
+          deepMerge(
+            targetValue,
+            sourceValue
+          );
+        } else {
+          target[key] = sourceValue;
+        }
+      }
+    }
+  }
+  return target;
+}
+function findExecutableOperation(input) {
+  const operations = input.query.definitions.filter(
+    (def) => def.kind === Kind.OPERATION_DEFINITION
+  );
+  if (operations.length === 0) {
+    return err(new Error("No operations found in query"));
+  }
+  if (operations.length === 1 && !input.operationName) {
+    return ok(operations[0]);
+  }
+  if (input.operationName) {
+    const specifiedOperation = operations.find((op) => {
+      var _a;
+      return ((_a = op.name) == null ? void 0 : _a.value) === input.operationName;
+    });
+    if (specifiedOperation) {
+      return ok(specifiedOperation);
+    }
+    return err(new Error(`Operation "${input.operationName}" not found in query`));
+  }
+  return err(new Error("Multiple operations found in query, and no operation name provided"));
+}
+function buildGraphQLInputExtension(input) {
+  const operationResult = findExecutableOperation(input);
+  if (operationResult.isErr()) {
+    return err(operationResult.error);
+  }
+  const operation = operationResult.value;
+  const selections = operation.selectionSet.selections;
+  const variableDefinitions = operation.variableDefinitions;
+  const variables = (variableDefinitions == null ? void 0 : variableDefinitions.reduce((prev, def) => {
+    var _a;
+    prev[def.variable.name.value] = {
+      definition: def,
+      value: (_a = input.variables) == null ? void 0 : _a[def.variable.name.value]
+    };
+    return prev;
+  }, {})) || {};
+  const fragments = input.query.definitions.filter(isFragmentDefinition).reduce((prev, fragment) => {
+    prev[fragment.name.value] = fragment;
+    return prev;
+  }, {});
+  return ok({
+    selections,
+    request: { definitions: { variables, fragments } },
+    parentFieldSelection: void 0
+  });
+}
+function buildAugmentedFieldSelection(newSelection, selections, fragments) {
+  var _a;
+  if (selectionExists(newSelection, selections)) {
+    return void 0;
+  }
+  const baseAlias = ((_a = newSelection.alias) == null ? void 0 : _a.value) || newSelection.name.value;
+  const baseInjectedAlias = `framework_augmented_${baseAlias}`;
+  const baseAliasedSelection = {
+    ...newSelection,
+    alias: {
+      kind: Kind.NAME,
+      value: baseInjectedAlias
+    }
+  };
+  if (selectionExists(baseAliasedSelection, selections)) {
+    return void 0;
+  }
+  const fieldName = getUniqueSelectionName(baseInjectedAlias, selections, fragments);
+  return {
+    ...newSelection,
+    alias: {
+      kind: Kind.NAME,
+      value: fieldName
+    }
+  };
+}
+function selectionExists(selection, selections) {
+  return selections.some((s) => selectionEquals(selection, s));
+}
+function selectionEquals(a, b) {
+  var _a, _b, _c, _d, _e, _f;
+  if (a.kind !== b.kind) {
+    return false;
+  }
+  if (a.kind === Kind.FIELD) {
+    const bField = b;
+    return !!(a.name.value === bField.name.value) && !!(((_a = a.alias) == null ? void 0 : _a.value) === ((_b = bField.alias) == null ? void 0 : _b.value)) && argumentsEqual(a.arguments, bField.arguments) && selectionSetsEqual((_c = a.selectionSet) == null ? void 0 : _c.selections, (_d = bField.selectionSet) == null ? void 0 : _d.selections) && directivesEqual(a.directives, bField.directives);
+  }
+  if (a.kind === Kind.FRAGMENT_SPREAD) {
+    const bFragmentSpread = b;
+    return a.name.value === bFragmentSpread.name.value && directivesEqual(a.directives, bFragmentSpread.directives);
+  }
+  const bInlineFragment = b;
+  return a.typeCondition === bInlineFragment.typeCondition && directivesEqual(a.directives, bInlineFragment.directives) && selectionSetsEqual((_e = a.selectionSet) == null ? void 0 : _e.selections, (_f = bInlineFragment.selectionSet) == null ? void 0 : _f.selections);
+}
+function argumentValueEquals(a, b) {
+  if (a.kind !== b.kind) {
+    return false;
+  }
+  switch (a.kind) {
+    case Kind.STRING:
+    case Kind.INT:
+    case Kind.FLOAT:
+    case Kind.BOOLEAN:
+    case Kind.ENUM:
+      return a.value === b.value;
+    case Kind.NULL:
+      return true;
+    case Kind.VARIABLE:
+      return a.name.value === b.name.value;
+    case Kind.LIST:
+      const bList = b;
+      if (a.values.length !== bList.values.length) {
+        return false;
+      }
+      return a.values.every((val, index) => argumentValueEquals(val, bList.values[index]));
+    case Kind.OBJECT:
+      const bObject = b;
+      if (a.fields.length !== bObject.fields.length) {
+        return false;
+      }
+      return a.fields.every((field, index) => {
+        const bField = bObject.fields[index];
+        return field.name.value === bField.name.value && argumentValueEquals(field.value, bField.value);
+      });
+    default:
+      return false;
+  }
+}
+function directivesEqual(a, b) {
+  if (a === void 0 && b === void 0) {
+    return true;
+  }
+  if (a === void 0 || b === void 0) {
+    return ((a == null ? void 0 : a.length) || 0) === ((b == null ? void 0 : b.length) || 0);
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((directive, index) => {
+    const bDirective = b[index];
+    return directive.name.value === bDirective.name.value && argumentsEqual(directive.arguments, bDirective.arguments);
+  });
+}
+function argumentsEqual(a, b) {
+  if (a === void 0 && b === void 0) {
+    return true;
+  }
+  if (a === void 0 || b === void 0) {
+    return ((a == null ? void 0 : a.length) || 0) === ((b == null ? void 0 : b.length) || 0);
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((arg, index) => {
+    const bArg = b[index];
+    return arg.name.value === bArg.name.value && argumentValueEquals(arg.value, bArg.value);
+  });
+}
+function selectionSetsEqual(a, b) {
+  return a === void 0 || b === void 0 || !!(a.length === b.length) && !!a.every((selection, index) => {
+    return selectionEquals(selection, b[index]);
+  });
+}
+function getUniqueSelectionName(fieldName, selections, fragments) {
+  const fieldNames = collectFieldNames(selections, fragments);
+  if (!fieldNames.includes(fieldName)) {
+    return fieldName;
+  }
+  let i = 1;
+  while (fieldNames.includes(`${fieldName}_${i}`)) {
+    i++;
+  }
+  return `${fieldName}_${i}`;
+}
+function collectFieldNames(selections, fragments) {
+  var _a;
+  const fieldNames = /* @__PURE__ */ new Set();
+  for (const selection of selections) {
+    if (isField(selection)) {
+      fieldNames.add(((_a = selection.alias) == null ? void 0 : _a.value) || selection.name.value);
+    } else if (isInlineFragment(selection)) {
+      collectFieldNames(
+        selection.selectionSet.selections,
+        fragments
+      ).forEach((name) => fieldNames.add(name));
+    } else if (isFragmentSpread(selection)) {
+      const fragment = fragments[selection.name.value];
+      if (fragment) {
+        collectFieldNames(
+          fragment.selectionSet.selections,
+          fragments
+        ).forEach((name) => fieldNames.add(name));
+      }
+    }
+  }
+  return Array.from(fieldNames);
+}
+function buildFieldKey(canonicalFieldName, fieldArguments, variables) {
+  if (fieldArguments === void 0 || fieldArguments.length === 0) {
+    return ok(canonicalFieldName);
+  }
+  const formattedArguments = {};
+  for (const arg of fieldArguments) {
+    const result = extractValue(arg.value, variables);
+    if (result.isErr()) {
+      return err(
+        new Error(
+          `Failed to extract argument '${arg.name.value}' for field '${canonicalFieldName}': ${result.error.message}`
+        )
+      );
+    }
+    formattedArguments[arg.name.value] = result.value;
+  }
+  return ok(`${canonicalFieldName}::${stableJSONStringify({ args: formattedArguments })}`);
+}
+const TYPENAME_FIELD = {
+  kind: Kind.FIELD,
+  name: {
+    kind: Kind.NAME,
+    value: "__typename"
+  }
+};
+function addTypenameToDocument(doc) {
+  return visit(doc, {
+    SelectionSet: {
+      enter(node, _key, parent) {
+        if (isOperationDefinition(parent)) {
+          return;
+        }
+        const { selections } = node;
+        if (!selections || selections.length === 0) {
+          return;
+        }
+        const skip = selections.some((selection) => {
+          return isField(selection) && (selection.name.value === "__typename" || selection.name.value.lastIndexOf("__", 0) === 0);
+        });
+        if (skip) {
+          return;
+        }
+        return {
+          ...node,
+          selections: [...selections, TYPENAME_FIELD]
+        };
+      }
+    }
+  });
+}
+function isOperationDefinition(parent) {
+  return !!parent && !Array.isArray(parent) && parent.kind === Kind.OPERATION_DEFINITION;
+}
+function isField(node) {
+  return node.kind === Kind.FIELD;
+}
+function isFragmentSpread(node) {
+  return node.kind === Kind.FRAGMENT_SPREAD;
+}
+function isInlineFragment(node) {
+  return node.kind === Kind.INLINE_FRAGMENT;
+}
+function isFragmentDefinition(node) {
+  return node.kind === Kind.FRAGMENT_DEFINITION;
+}
+function extractIfArgument(directive, variables, directiveName) {
+  var _a;
+  const ifArg = (_a = directive.arguments) == null ? void 0 : _a.find((arg) => arg.name.value === "if");
+  if (!ifArg) {
+    return err(new Error(`@${directiveName} directive requires an 'if' argument`));
+  }
+  const result = extractValue(ifArg.value, variables, { type: "boolean", nullable: false });
+  if (result.isErr()) {
+    return err(result.error);
+  }
+  return ok(result.value);
+}
+function shouldSkip(selection, variables) {
+  if (!selection.directives || selection.directives.length === 0) {
+    return ok(false);
+  }
+  for (const directive of selection.directives) {
+    if (directive.name.value === "skip") {
+      const ifResult = extractIfArgument(directive, variables, "skip");
+      if (ifResult.isErr()) {
+        return ifResult;
+      }
+      if (ifResult.value === true) {
+        return ok(true);
+      }
+    }
+    if (directive.name.value === "include") {
+      const ifResult = extractIfArgument(directive, variables, "include");
+      if (ifResult.isErr()) {
+        return ifResult;
+      }
+      if (ifResult.value === false) {
+        return ok(true);
+      }
+    }
+  }
+  return ok(false);
+}
+class BaseScalarFieldDef {
+  constructor(nullable) {
+    this.nullable = nullable;
+  }
+  write(_cache, input) {
+    if (input.data === void 0) {
+      return ok({ type: "missing" });
+    }
+    if (input.data === null) {
+      if (!this.nullable) {
+        return err([
+          {
+            type: "unknown",
+            error: new Error(
+              `Got a null value for non-nullable field "${input.selection.name.value}"`
+            )
+          }
+        ]);
+      }
+    }
+    return ok({ type: "data", data: input.data });
+  }
+  read(_cache, input) {
+    const normalizedData = input.normalizedData;
+    if (normalizedData.type === "missing") {
+      return ok(void 0);
+    }
+    return ok(normalizedData.data);
+  }
+  augmentSelections(input) {
+    return input;
+  }
+  buildFieldKey(selection, variables) {
+    return buildFieldKey(selection.name.value, selection.arguments, variables);
+  }
+}
+class BaseArrayFieldDef {
+  constructor(items, nullable) {
+    this.items = items;
+    this.nullable = nullable;
+  }
+  augmentSelections(input) {
+    return this.items.augmentSelections(input);
+  }
+  buildFieldKey(selection, variables) {
+    return this.items.buildFieldKey(selection, variables);
+  }
+  write(cache, input) {
+    if (input.data === void 0) {
+      return ok({ type: "missing" });
+    }
+    if (input.data === null) {
+      if (!this.nullable) {
+        return err([
+          {
+            type: "unknown",
+            error: new Error(
+              `Got a null value for non-nullable field "${input.selection.name.value}"`
+            )
+          }
+        ]);
+      }
+      return ok({ type: "data", data: input.data });
+    }
+    if (!Array.isArray(input.data)) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(
+            `Got a non array value for array field "${input.selection.name.value}"`
+          )
+        }
+      ]);
+    }
+    const arrayNormalizationErrors = [];
+    const normalizedArray = [];
+    input.data.forEach((item, index) => {
+      var _a;
+      const existingItemData = (_a = input.existingNormalizedData) == null ? void 0 : _a[index];
+      const normalizedItemResult = this.items.write(cache, {
+        ...input,
+        data: item,
+        existingNormalizedData: existingItemData,
+        request: input.request,
+        selection: input.selection
+      });
+      if (normalizedItemResult.isOk()) {
+        normalizedArray.push(normalizedItemResult.value);
+      } else {
+        arrayNormalizationErrors.push(...normalizedItemResult.error);
+      }
+    });
+    if (arrayNormalizationErrors.length > 0) {
+      return err(arrayNormalizationErrors);
+    }
+    return ok({ type: "data", data: normalizedArray });
+  }
+  read(cache, input) {
+    const normalizedData = input.normalizedData;
+    if (normalizedData.type === "missing") {
+      return ok(void 0);
+    }
+    if (normalizedData.data === null) {
+      if (!this.nullable) {
+        return err([
+          {
+            type: "unknown",
+            error: new Error(
+              `Got a null value for non-nullable field "${input.selection.name.value}"`
+            )
+          }
+        ]);
+      }
+      return ok({ type: "data", data: null });
+    }
+    if (!Array.isArray(normalizedData.data)) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(
+            `Got a non array value for array field "${input.selection.name.value}"`
+          )
+        }
+      ]);
+    }
+    const arrayDenormalizationErrors = [];
+    const denormalizedArray = [];
+    normalizedData.data.forEach((item) => {
+      const denormalizedItemResult = this.items.read(cache, {
+        ...input,
+        normalizedData: item,
+        request: input.request,
+        selection: input.selection
+      });
+      if (denormalizedItemResult.isOk()) {
+        denormalizedArray.push(denormalizedItemResult.value);
+      } else {
+        arrayDenormalizationErrors.push(...denormalizedItemResult.error);
+      }
+    });
+    if (arrayDenormalizationErrors.length > 0) {
+      return err(arrayDenormalizationErrors);
+    }
+    return ok(denormalizedArray);
+  }
+}
+class BaseObjectFieldDef {
+  constructor(repository, nullable) {
+    this.repository = repository;
+    this.nullable = nullable;
+  }
+  augmentSelections(input) {
+    return this.repository.augmentSelections(input);
+  }
+  buildFieldKey(selection, variables) {
+    return this.repository.buildFieldKey(selection, variables);
+  }
+  write(cache, input) {
+    var _a;
+    if (!input.selection.selectionSet) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(
+            `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
+          )
+        }
+      ]);
+    }
+    if (input.data === void 0) {
+      return ok({ type: "missing" });
+    }
+    if (input.data === null) {
+      if (!this.nullable) {
+        return err([
+          {
+            type: "unknown",
+            error: new Error(
+              `Got a null value for non-nullable field "${input.selection.name.value}"`
+            )
+          }
+        ]);
+      }
+      return ok({ type: "data", data: null });
+    }
+    const writeResult = this.repository.write(cache, {
+      ...input,
+      data: input.data,
+      existingNormalizedData: (_a = input.existingNormalizedData) == null ? void 0 : _a.data,
+      request: input.request,
+      selections: input.selection.selectionSet.selections,
+      parentFieldSelection: input.selection
+    });
+    if (writeResult.isErr()) {
+      return writeResult;
+    }
+    return ok({ type: "data", data: writeResult.value });
+  }
+  read(cache, input) {
+    var _a;
+    if (!input.selection.selectionSet) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(
+            `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
+          )
+        }
+      ]);
+    }
+    const normalizedData = input.normalizedData;
+    if (normalizedData.type === "missing") {
+      return ok(void 0);
+    }
+    if (normalizedData.data === null) {
+      if (!this.nullable) {
+        return err([
+          {
+            type: "unknown",
+            error: new Error(
+              `Got a null value for non-nullable field "${input.selection.name.value}"`
+            )
+          }
+        ]);
+      }
+      return ok(null);
+    }
+    return this.repository.read(cache, {
+      ...input,
+      normalizedData: normalizedData.data,
+      request: input.request,
+      selections: (_a = input.selection.selectionSet) == null ? void 0 : _a.selections,
+      parentFieldSelection: input.selection
+    });
+  }
+}
+const missingFieldDef = new BaseScalarFieldDef(false);
+class BaseGraphQLTypeRepository {
+  equals(x, y) {
+    return deepEquals(x, y);
+  }
+  augmentSelections(input) {
+    const augmentedSelections = [];
+    let augmentedFragments = { ...input.fragments };
+    for (const selection of input.selections) {
+      if (isField(selection)) {
+        const result = this.augmentFieldSelection(selection, augmentedFragments);
+        augmentedSelections.push(...result.selections);
+        augmentedFragments = result.fragments;
+      } else if (isInlineFragment(selection)) {
+        const augmentedFragmentSelections = this.augmentInlineFragmentSelection(
+          selection,
+          augmentedFragments
+        );
+        augmentedSelections.push(...augmentedFragmentSelections.selections);
+        augmentedFragments = augmentedFragmentSelections.fragments;
+      } else {
+        const augmentedFragmentSelections = this.augmentFragmentSpreadSelection(
+          selection,
+          augmentedFragments
+        );
+        augmentedSelections.push(...augmentedFragmentSelections.selections);
+        augmentedFragments = augmentedFragmentSelections.fragments;
+      }
+    }
+    const newTypenameSelection = buildAugmentedFieldSelection(
+      {
+        kind: Kind.FIELD,
+        name: {
+          kind: Kind.NAME,
+          value: "__typename"
+        }
+      },
+      [...augmentedSelections, ...input.selections],
+      augmentedFragments
+    );
+    if (newTypenameSelection) {
+      augmentedSelections.push(newTypenameSelection);
+    }
+    return { selections: augmentedSelections, fragments: augmentedFragments };
+  }
+  augmentFieldSelection(selection, fragments) {
+    var _a;
+    const field = this.getFieldDef(void 0, selection);
+    if (field === void 0) {
+      return { selections: [selection], fragments };
+    }
+    const result = field.augmentSelections({
+      selections: ((_a = selection.selectionSet) == null ? void 0 : _a.selections) || [],
+      fragments
+    });
+    return {
+      selections: [
+        {
+          ...selection,
+          selectionSet: {
+            kind: Kind.SELECTION_SET,
+            selections: result.selections
+          }
+        }
+      ],
+      fragments: result.fragments
+    };
+  }
+  augmentInlineFragmentSelection(fragment, fragments) {
+    var _a;
+    const satisfiedFragmentTypeConditionResult = this.satisfiesFragmentTypeCondition(
+      void 0,
+      fragment
+    );
+    if (satisfiedFragmentTypeConditionResult.isErr() || !satisfiedFragmentTypeConditionResult.value) {
+      return { selections: [], fragments };
+    }
+    const augmentedFragmentSelections = this.augmentSelections({
+      selections: ((_a = fragment.selectionSet) == null ? void 0 : _a.selections) || [],
+      fragments
+    });
+    return {
+      selections: [
+        {
+          ...fragment,
+          selectionSet: {
+            kind: Kind.SELECTION_SET,
+            selections: augmentedFragmentSelections.selections
+          }
+        }
+      ],
+      fragments: augmentedFragmentSelections.fragments
+    };
+  }
+  augmentFragmentSpreadSelection(selection, fragments) {
+    var _a;
+    const fragment = fragments[selection.name.value];
+    if (fragment === void 0) {
+      return { selections: [selection], fragments };
+    }
+    const satisfiedFragmentTypeConditionResult = this.satisfiesFragmentTypeCondition(
+      void 0,
+      fragment
+    );
+    if (satisfiedFragmentTypeConditionResult.isErr() || !satisfiedFragmentTypeConditionResult.value) {
+      return { selections: [selection], fragments };
+    }
+    const augmentedFragment = this.augmentSelections({
+      selections: ((_a = fragment.selectionSet) == null ? void 0 : _a.selections) || [],
+      fragments
+    });
+    return {
+      selections: [selection],
+      fragments: {
+        ...augmentedFragment.fragments,
+        [fragment.name.value]: {
+          ...fragment,
+          selectionSet: {
+            kind: Kind.SELECTION_SET,
+            selections: augmentedFragment.selections
+          }
+        }
+      }
+    };
+  }
+  normalizeSelections(cache, input) {
+    const normalized = {};
+    const errors = [];
+    for (const selection of input.selections) {
+      if (isField(selection)) {
+        deepMerge(
+          normalized,
+          this.normalizeFieldSelection(cache, input, selection, errors)
+        );
+      } else {
+        let fragment;
+        if (isInlineFragment(selection)) {
+          fragment = selection;
+        } else {
+          const fragmentDefinition = input.request.definitions.fragments[selection.name.value];
+          if (fragmentDefinition === void 0) {
+            continue;
+          }
+          fragment = {
+            ...fragmentDefinition,
+            directives: [
+              ...selection.directives || [],
+              ...fragmentDefinition.directives || []
+            ]
+          };
+        }
+        deepMerge(normalized, this.normalizeFragment(cache, input, fragment, errors));
+      }
+    }
+    return buildReadWriteResult(normalized, errors);
+  }
+  normalizeFieldSelection(cache, input, selection, errorCollector) {
+    var _a;
+    const canonicalFieldName = selection.name.value;
+    const dataInstanceFieldName = ((_a = selection.alias) == null ? void 0 : _a.value) ?? selection.name.value;
+    const value = input.data[dataInstanceFieldName];
+    const fieldDef = this.getFieldDef(input, selection);
+    if (!fieldDef) {
+      errorCollector.push({
+        type: "unknown",
+        error: new Error(
+          `GraphQL query requests unknown field "${canonicalFieldName}" on type "${this.typeName}". Expected one of fields ${Object.keys(this.fields)}.`
+        )
+      });
+      return {};
+    }
+    const shouldSkipResult = shouldSkip(selection, input.request.definitions.variables);
+    if (shouldSkipResult.isErr()) {
+      errorCollector.push({
+        type: "unknown",
+        error: shouldSkipResult.error
+      });
+      return {};
+    }
+    if (shouldSkipResult.value) {
+      return {};
+    }
+    const existingFieldDataResult = this.getNormalizedFieldData(selection, input);
+    if (existingFieldDataResult.isErr()) {
+      errorCollector.push({
+        type: "unknown",
+        error: existingFieldDataResult.error
+      });
+      return {};
+    }
+    const existingFieldData = existingFieldDataResult.value;
+    const cacheFieldKeyResult = fieldDef.buildFieldKey(
+      selection,
+      input.request.definitions.variables
+    );
+    if (cacheFieldKeyResult.isErr()) {
+      errorCollector.push({
+        type: "unknown",
+        error: cacheFieldKeyResult.error
+      });
+      return {};
+    }
+    const cacheFieldKey = cacheFieldKeyResult.value;
+    return {
+      [cacheFieldKey]: extractReadWriteData(
+        fieldDef.write(cache, {
+          ...input,
+          data: value,
+          existingNormalizedData: existingFieldData,
+          request: input.request,
+          selection
+        }),
+        errorCollector
+      )
+    };
+  }
+  normalizeFragment(cache, input, fragment, errorCollector) {
+    const shouldProcessResult = this.shouldProcessFragment(input, fragment);
+    if (shouldProcessResult.isErr()) {
+      errorCollector.push({
+        type: "unknown",
+        error: shouldProcessResult.error
+      });
+      return {};
+    }
+    if (shouldProcessResult.value) {
+      return extractReadWriteData(
+        this.normalizeSelections(cache, {
+          ...input,
+          selections: fragment.selectionSet.selections
+          // readonly casting, todo
+        }),
+        errorCollector
+      ) || {};
+    }
+    return {};
+  }
+  denormalizeSelections(cache, input) {
+    const errors = [];
+    const denormalized = {};
+    for (const selection of input.selections) {
+      if (isField(selection)) {
+        deepMerge(
+          denormalized,
+          this.denormalizeFieldSelection(cache, input, selection, errors)
+        );
+      } else {
+        let fragment;
+        if (isInlineFragment(selection)) {
+          fragment = selection;
+        } else {
+          const fragmentDefinition = input.request.definitions.fragments[selection.name.value];
+          if (fragmentDefinition === void 0) {
+            continue;
+          }
+          fragment = {
+            ...fragmentDefinition,
+            directives: [
+              ...selection.directives || [],
+              ...fragmentDefinition.directives || []
+            ]
+          };
+        }
+        deepMerge(denormalized, this.denormalizeFragment(cache, input, fragment, errors));
+      }
+    }
+    return buildReadWriteResult(denormalized, errors);
+  }
+  getNormalizedFieldData(selection, input) {
+    var _a;
+    const fieldDef = this.getFieldDef(input, selection);
+    if (!fieldDef) {
+      return err(
+        new Error(
+          `Unknown field "${selection.name.value}" on type "${this.typeName}". Expected one of fields ${Object.keys(this.fields)}.`
+        )
+      );
+    }
+    const cacheFieldKeyResult = fieldDef.buildFieldKey(
+      selection,
+      input.request.definitions.variables
+    );
+    if (cacheFieldKeyResult.isErr()) {
+      return err(cacheFieldKeyResult.error);
+    }
+    const cacheFieldKey = cacheFieldKeyResult.value;
+    return ok((_a = input.existingNormalizedData || input.normalizedData) == null ? void 0 : _a[cacheFieldKey]);
+  }
+  denormalizeFieldSelection(cache, input, selection, errorCollector) {
+    var _a;
+    const canonicalFieldName = selection.name.value;
+    const fieldDef = this.getFieldDef(input, selection);
+    if (!fieldDef) {
+      errorCollector.push({
+        type: "unknown",
+        error: new Error(
+          `GraphQL query requests unknown field "${canonicalFieldName}" on type "${this.typeName}". Expected one of fields ${Object.keys(this.fields)}.`
+        )
+      });
+      return {};
+    }
+    const dataInstanceFieldName = ((_a = selection.alias) == null ? void 0 : _a.value) ?? selection.name.value;
+    const normalizedFieldDataResult = this.getNormalizedFieldData(selection, input);
+    if (normalizedFieldDataResult.isErr()) {
+      errorCollector.push({
+        type: "unknown",
+        error: normalizedFieldDataResult.error
+      });
+      return {};
+    }
+    const shouldSkipResult = shouldSkip(selection, input.request.definitions.variables);
+    if (shouldSkipResult.isErr()) {
+      errorCollector.push({
+        type: "unknown",
+        error: shouldSkipResult.error
+      });
+      return {};
+    }
+    if (shouldSkipResult.value) {
+      return {};
+    }
+    const normalizedFieldValue = normalizedFieldDataResult.value;
+    if (normalizedFieldValue === void 0) {
+      errorCollector.push({
+        type: "missingData",
+        namespace: this.namespace,
+        typeName: this.typeName,
+        data: canonicalFieldName
+      });
+      return {};
+    }
+    const fieldData = extractReadWriteData(
+      fieldDef.read(cache, {
+        ...input,
+        normalizedData: normalizedFieldValue,
+        request: input.request,
+        selection
+      }),
+      errorCollector
+    );
+    if (fieldData === void 0) {
+      return {};
+    }
+    return {
+      [dataInstanceFieldName]: fieldData
+    };
+  }
+  denormalizeFragment(cache, input, fragment, errorCollector) {
+    const shouldProcessResult = this.shouldProcessFragment(input, fragment);
+    if (shouldProcessResult.isErr()) {
+      errorCollector.push({
+        type: "unknown",
+        error: shouldProcessResult.error
+      });
+      return {};
+    }
+    if (shouldProcessResult.value) {
+      return extractReadWriteData(
+        this.denormalizeSelections(cache, {
+          ...input,
+          selections: fragment.selectionSet.selections
+          // readonly casting, todo
+        }),
+        errorCollector
+      ) || {};
+    }
+    return {};
+  }
+  getFieldDef(input, selection) {
+    var _a, _b, _c;
+    const canonicalFieldName = selection.name.value;
+    const fieldDef = this.fields[canonicalFieldName];
+    if (fieldDef) {
+      return fieldDef;
+    }
+    const dataInstanceFieldName = ((_a = selection.alias) == null ? void 0 : _a.value) ?? selection.name.value;
+    if (input === void 0) {
+      return void 0;
+    }
+    if ("data" in input && input.data[dataInstanceFieldName] === void 0) {
+      return missingFieldDef;
+    } else if ("normalizedData" in input && ((_c = (_b = input.normalizedData) == null ? void 0 : _b[dataInstanceFieldName]) == null ? void 0 : _c.type) === "missing") {
+      return missingFieldDef;
+    }
+    return void 0;
+  }
+  shouldProcessFragment(input, fragment) {
+    const shouldSkipResult = shouldSkip(fragment, input.request.definitions.variables);
+    if (shouldSkipResult.isErr()) {
+      return shouldSkipResult;
+    }
+    if (shouldSkipResult.value) {
+      return ok(false);
+    }
+    return this.satisfiesFragmentTypeCondition(input, fragment);
+  }
+  satisfiesFragmentTypeCondition(_input, fragment) {
+    if (!fragment.typeCondition) {
+      return ok(true);
+    }
+    const conditionalTypeName = fragment.typeCondition.name.value;
+    if (conditionalTypeName === this.typeName) {
+      return ok(true);
+    }
+    if (this.implementedInterfaces.includes(conditionalTypeName)) {
+      return ok(true);
+    }
+    return ok(false);
+  }
+  getCacheKeyFieldArguments(selection) {
+    return selection.arguments;
+  }
+  buildFieldKey(selection, variables) {
+    return buildFieldKey(
+      selection.name.value,
+      this.getCacheKeyFieldArguments(selection),
+      variables
+    );
+  }
+}
+class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
+  constructor() {
+    super(...arguments);
+    this.idField = "id";
+    this._graphqlRepository = void 0;
+    this.LocalGraphQLRepository = class extends BaseGraphQLTypeRepository {
+      constructor(namespace, typeName, implementedInterfaces, fields, idField) {
+        super();
+        this.namespace = namespace;
+        this.typeName = typeName;
+        this.implementedInterfaces = implementedInterfaces;
+        this.fields = fields;
+        this.idField = idField;
+      }
+      augmentSelections(input) {
+        const result = super.augmentSelections(input);
+        const augmentedSelections = result.selections;
+        let augmentedFragments = result.fragments;
+        const newSelection = buildAugmentedFieldSelection(
+          {
+            kind: Kind.FIELD,
+            name: {
+              kind: Kind.NAME,
+              value: this.idField
+            }
+          },
+          [...augmentedSelections, ...input.selections],
+          augmentedFragments
+        );
+        if (newSelection) {
+          augmentedSelections.push(newSelection);
+        }
+        return { selections: augmentedSelections, fragments: augmentedFragments };
+      }
+    };
+  }
+  get graphqlRepository() {
+    if (this._graphqlRepository === void 0) {
+      this._graphqlRepository = new this.LocalGraphQLRepository(this.namespace, this.typeName, this.implementedInterfaces, this.fields, this.idField);
+    }
+    return this._graphqlRepository;
+  }
+  write(cache, input) {
+    const key = this.buildKey(this.buildKeyParams(input));
+    const normalized = this.normalizeData(cache, input);
+    if (normalized.isErr()) {
+      return err(normalized.error);
+    }
+    const existing = cache.get(key);
+    if (!deepEquals(existing == null ? void 0 : existing.value, normalized.value)) {
+      cache.set(key, {
+        value: normalized.value,
+        metadata: this.cacheMetadata
+      });
+    }
+    return ok({
+      type: "link",
+      linkedKey: key
+    });
+  }
+  normalizeData(cache, input) {
+    const key = this.buildKey(this.buildKeyParams(input));
+    const existingNormalizedData = cache.get(key, { copy: true });
+    const normalizeDataResult = this.graphqlRepository.normalizeSelections(cache, {
+      ...input,
+      existingNormalizedData: existingNormalizedData == null ? void 0 : existingNormalizedData.value
+    });
+    if (normalizeDataResult.isErr()) {
+      return normalizeDataResult;
+    }
+    return ok(
+      deepMerge(
+        {},
+        (existingNormalizedData == null ? void 0 : existingNormalizedData.value) || {},
+        normalizeDataResult.value
+      )
+    );
+  }
+  denormalizeData(cache, input) {
+    return this.graphqlRepository.denormalizeSelections(cache, input);
+  }
+  augmentSelections(input) {
+    return this.graphqlRepository.augmentSelections(input);
+  }
+  buildFieldKey(selection, variables) {
+    return this.graphqlRepository.buildFieldKey(selection, variables);
+  }
+  buildKeyParams(input) {
+    var _a;
+    const idField = input.selections.find(
+      (selection) => selection.kind === Kind.FIELD && selection.name.value === this.idField
+    );
+    if (!idField) {
+      throw new Error(`Id field ${this.idField} not found in selections`);
+    }
+    const idFieldDataProperty = ((_a = idField.alias) == null ? void 0 : _a.value) || idField.name.value;
+    return {
+      [this.idField]: input.data[idFieldDataProperty]
+    };
+  }
+}
+class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepository {
+  constructor() {
+    super(...arguments);
+    this.implementedInterfaces = [];
+    this._rootGraphqlRepository = void 0;
+    this.LocalRootGraphQLRepository = class extends BaseGraphQLTypeRepository {
+      constructor(namespace, typeName, implementedInterfaces, fields, idField) {
+        super();
+        this.namespace = namespace;
+        this.typeName = typeName;
+        this.implementedInterfaces = implementedInterfaces;
+        this.fields = fields;
+        this.idField = idField;
+      }
+    };
+  }
+  get graphqlRepository() {
+    if (this._rootGraphqlRepository === void 0) {
+      this._rootGraphqlRepository = new this.LocalRootGraphQLRepository(
+        this.namespace,
+        this.typeName,
+        this.implementedInterfaces,
+        this.fields,
+        this.idField
+      );
+    }
+    return this._rootGraphqlRepository;
+  }
+  augmentSelections(input) {
+    return this.graphqlRepository.augmentSelections(input);
+  }
+  buildKeyParams(_input) {
+    return null;
+  }
+  denormalizeData(cache, input) {
+    const result = super.denormalizeData(cache, input);
+    if (result.isErr()) {
+      return result;
+    }
+    return ok({
+      data: result.value
+    });
+  }
+  buildAugmentedQuery(input) {
+    var _a;
+    const operationResult = findExecutableOperation(input);
+    if (operationResult.isErr()) {
+      return err(operationResult.error);
+    }
+    const operation = operationResult.value;
+    const fragmentDefinitions = input.query.definitions.filter(
+      (def) => def.kind === Kind.FRAGMENT_DEFINITION
+    );
+    const fragments = fragmentDefinitions.reduce(
+      (acc, def) => {
+        acc[def.name.value] = def;
+        return acc;
+      },
+      {}
+    );
+    const result = this.augmentSelections({
+      selections: ((_a = operationResult.value.selectionSet) == null ? void 0 : _a.selections) || [],
+      fragments
+    });
+    const augmentedOperationSelections = result.selections;
+    let augmentedFragments = result.fragments;
+    const augmentedOperation = {
+      ...operation,
+      selectionSet: { kind: Kind.SELECTION_SET, selections: augmentedOperationSelections }
+    };
+    return ok({
+      ...input.query,
+      definitions: [
+        ...input.query.definitions.filter((def) => def.kind !== Kind.FRAGMENT_DEFINITION).map((def) => {
+          if (def.kind !== Kind.OPERATION_DEFINITION || def !== operation) {
+            return def;
+          }
+          return augmentedOperation;
+        }),
+        ...Object.values(augmentedFragments)
+      ]
+    });
+  }
+}
+class UnidentifiableGraphQLTypeRepository extends BaseGraphQLTypeRepository {
+  constructor(services) {
+    super();
+    this.services = services;
+  }
+  write(cache, input) {
+    return this.normalizeSelections(cache, input);
+  }
+  read(cache, input) {
+    return this.denormalizeSelections(cache, input);
+  }
+}
+class BaseInterfaceRepository {
+  constructor(services) {
+    this.services = services;
+  }
+  equals(x, y) {
+    return deepEquals(x, y);
+  }
+  write(cache, input) {
+    if (typeof input.data !== "object") {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(`Got a non-object value for ${this.typeName} field"`)
+        }
+      ]);
+    }
+    const discriminator = this.getTypeDiscriminator(input.data, input.selections);
+    const concreteTypeRepository = this.possibleTypes[discriminator];
+    if (!concreteTypeRepository) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(
+            `Unknown discriminator "${discriminator}" for ${this.typeName} field, expected one of ${Object.keys(this.possibleTypes)}`
+          )
+        }
+      ]);
+    }
+    const selectionErr = this.verifyInterfaceFields(input.selections);
+    if (selectionErr) {
+      return err(selectionErr);
+    }
+    const normalizeInput = {
+      ...input,
+      data: input.data,
+      existingNormalizedData: input.existingNormalizedData,
+      selections: input.selections,
+      request: input.request,
+      parentFieldSelection: input.parentFieldSelection
+    };
+    const result = concreteTypeRepository.write(cache, normalizeInput);
+    if (result.isOk()) {
+      return ok({ discriminator, data: result.value });
+    }
+    return result;
+  }
+  read(cache, input) {
+    const unionRep = input.normalizedData;
+    if (typeof unionRep.data !== "object" || unionRep.data === null) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(`Got a non-object value for ${this.typeName} field.`)
+        }
+      ]);
+    }
+    const discriminator = unionRep.discriminator;
+    const concreteRepository = this.possibleTypes[discriminator];
+    if (!concreteRepository) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(
+            `Unknown discriminator "${discriminator}" for ${this.typeName} field, expected one of ${Object.keys(this.possibleTypes)}`
+          )
+        }
+      ]);
+    }
+    const selectionErr = this.verifyInterfaceFields(input.selections);
+    if (selectionErr) {
+      return err(selectionErr);
+    }
+    const denormalizeInput = {
+      ...input,
+      normalizedData: unionRep.data,
+      selections: input.selections,
+      request: input.request,
+      parentFieldSelection: input.parentFieldSelection
+    };
+    const result = concreteRepository.read(cache, denormalizeInput);
+    return result;
+  }
+  augmentSelections(input) {
+    const augmentedSelections = [];
+    let augmentedFragments = { ...input.fragments };
+    input.selections.forEach((selection) => {
+      var _a;
+      if (selection.kind === Kind.FIELD) {
+        if (Object.keys(this.fields).includes(selection.name.value)) {
+          const field = this.fields[selection.name.value];
+          const result2 = field.augmentSelections({
+            selections: ((_a = selection.selectionSet) == null ? void 0 : _a.selections) || [],
+            fragments: input.fragments
+          });
+          augmentedSelections.push({
+            ...selection,
+            selectionSet: { kind: Kind.SELECTION_SET, selections: result2.selections }
+          });
+          augmentedFragments = result2.fragments;
+        } else {
+          augmentedSelections.push(selection);
+        }
+      }
+    });
+    const result = augmentUnionLikeSelections(
+      {
+        selections: [...input.selections, ...augmentedSelections],
+        fragments: augmentedFragments
+      },
+      this.possibleTypes
+    );
+    augmentedSelections.push(...result.selections);
+    augmentedFragments = result.fragments;
+    const newSelection = buildAugmentedFieldSelection(
+      { kind: Kind.FIELD, name: { kind: Kind.NAME, value: "__typename" } },
+      augmentedSelections,
+      input.fragments
+    );
+    if (newSelection) {
+      augmentedSelections.push(newSelection);
+    }
+    return { selections: augmentedSelections, fragments: augmentedFragments };
+  }
+  getTypeDiscriminator(data, selections) {
+    var _a;
+    const typenameSelection = selections.find(
+      (selection) => selection.kind === Kind.FIELD && selection.name.value === "__typename"
+    );
+    if (typenameSelection) {
+      return data[((_a = typenameSelection.alias) == null ? void 0 : _a.value) || typenameSelection.name.value];
+    } else {
+      return data.__typename;
+    }
+  }
+  verifyInterfaceFields(selections) {
+    let selectionErr;
+    selections.forEach((selection) => {
+      if (selection.kind === Kind.FIELD) {
+        const fieldName = selection.name.value;
+        const selectionAllowed = fieldName === "__typename" || Object.keys(this.fields).includes(fieldName);
+        if (!selectionAllowed) {
+          selectionErr = [
+            {
+              type: "unknown",
+              error: new Error(
+                `Dissallowed selection "${fieldName}" used outside of an inline fragment for interface type ${this.typeName}"`
+              )
+            }
+          ];
+          return;
+        }
+      }
+    });
+    return selectionErr;
+  }
+  buildFieldKey(selection, variables) {
+    return buildFieldKey(
+      selection.name.value,
+      this.getCacheKeyFieldArguments(selection),
+      variables
+    );
+  }
+  getCacheKeyFieldArguments(selection) {
+    return selection.arguments;
+  }
+}
+class BaseUnionRepository {
+  constructor(services) {
+    this.services = services;
+  }
+  equals(x, y) {
+    return deepEquals(x, y);
+  }
+  write(cache, input) {
+    if (typeof input.data !== "object") {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(`Got a non-object value for ${this.typeName} field"`)
+        }
+      ]);
+    }
+    const discriminator = this.getTypeDiscriminator(input.data, input.selections);
+    const concreteTypeRepository = this.possibleTypes[discriminator];
+    if (!concreteTypeRepository) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(
+            `Unknown discriminator "${discriminator}" for ${this.typeName} field, expected one of ${Object.keys(this.possibleTypes)}`
+          )
+        }
+      ]);
+    }
+    const selectionErr = this.verifyUnionFields(input.selections);
+    if (selectionErr) {
+      return err(selectionErr);
+    }
+    const normalizeInput = {
+      ...input,
+      data: input.data,
+      existingNormalizedData: input.existingNormalizedData,
+      selections: input.selections,
+      request: input.request,
+      parentFieldSelection: input.parentFieldSelection
+    };
+    const result = concreteTypeRepository.write(cache, normalizeInput);
+    if (result.isOk()) {
+      return ok({ discriminator, data: result.value });
+    }
+    return result;
+  }
+  read(cache, input) {
+    const unionRep = input.normalizedData;
+    if (typeof unionRep.data !== "object" || unionRep.data === null) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(`Got a non-object value for ${this.typeName} field.`)
+        }
+      ]);
+    }
+    const discriminator = unionRep.discriminator;
+    const concreteRepository = this.possibleTypes[discriminator];
+    if (!concreteRepository) {
+      return err([
+        {
+          type: "unknown",
+          error: new Error(
+            `Unknown discriminator "${discriminator}" for ${this.typeName} field, expected one of ${Object.keys(this.possibleTypes)}`
+          )
+        }
+      ]);
+    }
+    const selectionErr = this.verifyUnionFields(input.selections);
+    if (selectionErr) {
+      return err(selectionErr);
+    }
+    const denormalizeInput = {
+      ...input,
+      normalizedData: unionRep.data,
+      selections: input.selections,
+      request: input.request,
+      parentFieldSelection: input.parentFieldSelection
+    };
+    const result = concreteRepository.read(cache, denormalizeInput);
+    return result;
+  }
+  augmentSelections(input) {
+    const augmentedSelections = [];
+    let augmentedFragments = { ...input.fragments };
+    const result = augmentUnionLikeSelections(
+      {
+        selections: [...input.selections, ...augmentedSelections],
+        fragments: augmentedFragments
+      },
+      this.possibleTypes
+    );
+    augmentedSelections.push(...result.selections);
+    augmentedFragments = result.fragments;
+    const newSelection = buildAugmentedFieldSelection(
+      { kind: Kind.FIELD, name: { kind: Kind.NAME, value: "__typename" } },
+      augmentedSelections,
+      input.fragments
+    );
+    if (newSelection) {
+      augmentedSelections.push(newSelection);
+    }
+    return { selections: augmentedSelections, fragments: augmentedFragments };
+  }
+  getTypeDiscriminator(data, selections) {
+    var _a;
+    const typenameSelection = selections.find(
+      (selection) => selection.kind === Kind.FIELD && selection.name.value === "__typename"
+    );
+    if (typenameSelection) {
+      return data[((_a = typenameSelection.alias) == null ? void 0 : _a.value) || typenameSelection.name.value];
+    } else {
+      return data.__typename;
+    }
+  }
+  verifyUnionFields(selections) {
+    let selectionErr;
+    selections.forEach((selection) => {
+      if (selection.kind === Kind.FIELD) {
+        const fieldName = selection.name.value;
+        const selectionAllowed = fieldName === "__typename";
+        if (!selectionAllowed) {
+          selectionErr = [
+            {
+              type: "unknown",
+              error: new Error(
+                `Dissallowed selection "${fieldName}" used outside of an inline fragment for union type ${this.typeName}"`
+              )
+            }
+          ];
+          return;
+        }
+      }
+    });
+    return selectionErr;
+  }
+  buildFieldKey(selection, variables) {
+    return buildFieldKey(
+      selection.name.value,
+      this.getCacheKeyFieldArguments(selection),
+      variables
+    );
+  }
+  getCacheKeyFieldArguments(selection) {
+    return selection.arguments;
+  }
+}
+function augmentUnionLikeSelections(input, possibleTypes) {
+  const augmentedSelections = [];
+  let augmentedFragments = { ...input.fragments };
+  Object.values(possibleTypes).forEach((repository) => {
+    const result = repository.augmentSelections({
+      selections: [...input.selections, ...augmentedSelections],
+      fragments: augmentedFragments
+    });
+    const typeSelections = result.selections.filter((selection) => selection.kind !== Kind.FIELD).map((selection) => {
+      if (selection.kind === Kind.INLINE_FRAGMENT) {
+        return {
+          ...selection,
+          selectionSet: {
+            kind: Kind.SELECTION_SET,
+            selections: selection.selectionSet.selections
+          }
+        };
+      }
+      return selection;
+    });
+    augmentedSelections.push(...typeSelections);
+    augmentedFragments = result.fragments;
+  });
+  return { selections: augmentedSelections, fragments: augmentedFragments };
+}
+const GraphQLQueryJsonSchema = {
+  type: "object",
+  properties: {
+    query: true,
+    variables: { type: "object", properties: {}, required: [], additionalProperties: true },
+    operationName: { type: "string" }
+  },
+  required: ["query"],
+  additionalProperties: true
+};
+export {
+  BaseArrayFieldDef,
+  BaseGraphQLTypeRepository,
+  BaseInterfaceRepository,
+  BaseObjectFieldDef,
+  BaseScalarFieldDef,
+  BaseUnionRepository,
+  GraphQLDocumentRootTypeRepository,
+  GraphQLQueryJsonSchema,
+  IdentifiableGraphQLTypeRepository,
+  UnidentifiableGraphQLTypeRepository,
+  addTypenameToDocument,
+  buildAugmentedFieldSelection,
+  buildFieldKey,
+  buildGraphQLInputExtension,
+  deepMerge,
+  findExecutableOperation,
+  missingFieldDef,
+  shouldSkip
+};
+//# sourceMappingURL=index.js.map