graphql-jit 0.8.9-canary.f7574a0 → 0.8.10

package/README.md

@@ -123,31 +123,6 @@ Compiles the `document` AST, using an optional operationName and compiler option
   - `customSerializers` {Object as Map, default: {}} - Replace serializer functions for specific types. Can be used as a safer alternative
     for overly expensive serializers
   - `customJSONSerializer` {boolean, default: false} - Whether to produce also a JSON serializer function using `fast-json-stringify`. The default stringifier function is `JSON.stringify`
-  - `debug` {object, optional} - Publishes formatted generated executors as virtual JavaScript sources. This is intended for local development.
-    - `enabled` {boolean, required} - Enables all debug-only work. Set this to `false` to skip formatting and generated-source changes.
-    - `querySourceName` {string, optional} - A stable name for the generated query source, such as `graphql-jit://graphql-jit/my-service/GetProduct.query.js`.
-    - `variablesSourceName` {string, optional} - A stable name for the generated variable-coercion source, such as `graphql-jit://graphql-jit/my-service/GetProduct.variables.js`.
-    - `formatSourceCode` {(source: string) => string, optional} - A synchronous formatter that runs before compilation. e.g. `@prettier/sync`.
-
-### Debugging generated executors
-
-Start Node with `--inspect` and enable `debug` for the operation being investigated:
-
-```js
-const { format } = require("@prettier/sync");
-
-const compiledQuery = compileQuery(schema, document, "GetProduct", {
-  debug: {
-    enabled: true,
-    querySourceName: "graphql-jit://graphql-jit/shop/GetProduct.query.js",
-    variablesSourceName:
-      "graphql-jit://graphql-jit/shop/GetProduct.variables.js",
-    formatSourceCode: (source) => format(source, { parser: "babel" })
-  }
-});
-```
-
-The debugger exposes separate query and variable-coercion scripts. Set breakpoints directly in those generated JavaScript sources.
 
 #### compiledQuery.query(root: any, context: any, variables: Maybe<{ [key: string]: any }>)
 

package/dist/ast.d.mts

@@ -0,0 +1,7 @@
+import 'graphql';
+export { A as Arguments, F as FieldsAndNodes, t as JitFieldNode, O as ObjectPath, z as addPath, u as collectFields, v as collectSubfields, y as computeLocations, B as flattenPath, w as getArgumentDefs, H as joinSkipIncludePath, r as resolveFieldDef, D as serializeObjectPathForSkipInclude, x as valueFromAST } from './index-DtKZ-jVv.mjs';
+import '@graphql-typed-document-node/core';
+import './types.mjs';
+import './error.mjs';
+import './resolve-info.mjs';
+import './variables.mjs';

package/dist/ast.d.ts

@@ -0,0 +1,7 @@
+import 'graphql';
+export { A as Arguments, F as FieldsAndNodes, t as JitFieldNode, O as ObjectPath, z as addPath, u as collectFields, v as collectSubfields, y as computeLocations, B as flattenPath, w as getArgumentDefs, H as joinSkipIncludePath, r as resolveFieldDef, D as serializeObjectPathForSkipInclude, x as valueFromAST } from './index-CZg-2UMZ.js';
+import '@graphql-typed-document-node/core';
+import './types.js';
+import './error.js';
+import './resolve-info.js';
+import './variables.js';

package/dist/ast.js

@@ -0,0 +1,635 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ast_exports = {};
+__export(ast_exports, {
+  addPath: () => addPath,
+  collectFields: () => collectFields,
+  collectSubfields: () => collectSubfields,
+  computeLocations: () => computeLocations,
+  flattenPath: () => flattenPath,
+  getArgumentDefs: () => getArgumentDefs,
+  joinSkipIncludePath: () => joinSkipIncludePath,
+  resolveFieldDef: () => import_compat.resolveFieldDef,
+  serializeObjectPathForSkipInclude: () => serializeObjectPathForSkipInclude,
+  valueFromAST: () => valueFromAST
+});
+module.exports = __toCommonJS(ast_exports);
+var import_graphql = require("graphql");
+var import_execution = require("./execution.js");
+var import_inspect = __toESM(require("./inspect.js"));
+var import_compat = require("./compat.js");
+const inspect = (0, import_inspect.default)();
+function collectFields(compilationContext, runtimeType, selectionSet, fields, visitedFragmentNames, parentResponsePath) {
+  return collectFieldsImpl(
+    compilationContext,
+    runtimeType,
+    selectionSet,
+    fields,
+    visitedFragmentNames,
+    void 0,
+    serializeObjectPathForSkipInclude(parentResponsePath)
+  );
+}
+function collectFieldsImpl(compilationContext, runtimeType, selectionSet, fields, visitedFragmentNames, previousShouldInclude = [], parentResponsePath = "") {
+  const stack = [];
+  for (let i = selectionSet.selections.length - 1; i >= 0; i--) {
+    stack.push({
+      selection: selectionSet.selections[i],
+      parentResponsePath,
+      previousShouldInclude
+    });
+  }
+  while (stack.length > 0) {
+    const { selection, parentResponsePath: parentResponsePath2, previousShouldInclude: previousShouldInclude2 } = stack.pop();
+    switch (selection.kind) {
+      case import_graphql.Kind.FIELD: {
+        collectFieldsForField({
+          compilationContext,
+          fields,
+          parentResponsePath: parentResponsePath2,
+          previousShouldInclude: previousShouldInclude2,
+          selection
+        });
+        break;
+      }
+      case import_graphql.Kind.INLINE_FRAGMENT: {
+        if (!doesFragmentConditionMatch(
+          compilationContext,
+          selection,
+          runtimeType
+        )) {
+          break;
+        }
+        const compiledSkipInclude = compileSkipInclude(
+          compilationContext,
+          selection
+        );
+        const mergedShouldInclude = joinShouldIncludeCompilations(
+          previousShouldInclude2,
+          [compiledSkipInclude]
+        );
+        const selectionsLength = selection.selectionSet.selections.length;
+        for (let i = selectionsLength - 1; i >= 0; i--) {
+          stack.push({
+            selection: selection.selectionSet.selections[i],
+            parentResponsePath: parentResponsePath2,
+            previousShouldInclude: mergedShouldInclude
+          });
+        }
+        break;
+      }
+      case import_graphql.Kind.FRAGMENT_SPREAD: {
+        const fragName = selection.name.value;
+        if (visitedFragmentNames[fragName]) {
+          break;
+        }
+        visitedFragmentNames[fragName] = true;
+        const fragment = compilationContext.fragments[fragName];
+        if (!fragment || !doesFragmentConditionMatch(compilationContext, fragment, runtimeType)) {
+          break;
+        }
+        const compiledSkipInclude = compileSkipInclude(
+          compilationContext,
+          selection
+        );
+        const mergedShouldInclude = joinShouldIncludeCompilations(
+          previousShouldInclude2,
+          [compiledSkipInclude]
+        );
+        const selectionsLength = fragment.selectionSet.selections.length;
+        for (let i = selectionsLength - 1; i >= 0; i--) {
+          stack.push({
+            selection: fragment.selectionSet.selections[i],
+            parentResponsePath: parentResponsePath2,
+            previousShouldInclude: mergedShouldInclude
+          });
+        }
+        break;
+      }
+    }
+  }
+  return fields;
+}
+function collectFieldsForField({
+  compilationContext,
+  fields,
+  parentResponsePath,
+  previousShouldInclude,
+  selection
+}) {
+  const name = getFieldEntryKey(selection);
+  if (!fields[name]) {
+    fields[name] = [];
+  }
+  const fieldNode = selection;
+  const currentPath = joinSkipIncludePath(
+    parentResponsePath,
+    // use alias(instead of selection.name.value) if available as the responsePath used for lookup uses alias
+    name
+  );
+  const compiledSkipInclude = compileSkipInclude(compilationContext, selection);
+  if (compilationContext.options.useExperimentalPathBasedSkipInclude) {
+    if (!fieldNode.__internalShouldIncludePath)
+      fieldNode.__internalShouldIncludePath = {};
+    fieldNode.__internalShouldIncludePath[currentPath] = joinShouldIncludeCompilations(
+      fieldNode.__internalShouldIncludePath?.[currentPath] ?? [],
+      previousShouldInclude,
+      [compiledSkipInclude]
+    );
+  } else {
+    fieldNode.__internalShouldInclude = joinShouldIncludeCompilations(
+      fieldNode.__internalShouldInclude ?? [],
+      previousShouldInclude,
+      [compiledSkipInclude]
+    );
+  }
+  augmentFieldNodeTree(compilationContext, fieldNode, currentPath);
+  fields[name].push(fieldNode);
+}
+function augmentFieldNodeTree(compilationContext, rootFieldNode, parentResponsePath) {
+  for (const selection of rootFieldNode.selectionSet?.selections ?? []) {
+    const stack = [];
+    stack.push({
+      parentFieldNode: rootFieldNode,
+      selection,
+      comesFromFragmentSpread: false,
+      parentResponsePath
+    });
+    while (stack.length > 0) {
+      const {
+        parentFieldNode,
+        selection: selection2,
+        comesFromFragmentSpread,
+        parentResponsePath: parentResponsePath2
+      } = stack.pop();
+      switch (selection2.kind) {
+        case import_graphql.Kind.FIELD: {
+          const jitFieldNode = selection2;
+          const currentPath = joinSkipIncludePath(
+            parentResponsePath2,
+            // use alias(instead of selection.name.value) if available as the responsePath used for lookup uses alias
+            getFieldEntryKey(jitFieldNode)
+          );
+          if (!comesFromFragmentSpread) {
+            if (compilationContext.options.useExperimentalPathBasedSkipInclude) {
+              if (!jitFieldNode.__internalShouldIncludePath)
+                jitFieldNode.__internalShouldIncludePath = {};
+              jitFieldNode.__internalShouldIncludePath[currentPath] = joinShouldIncludeCompilations(
+                parentFieldNode.__internalShouldIncludePath?.[parentResponsePath2] ?? [],
+                jitFieldNode.__internalShouldIncludePath?.[currentPath] ?? []
+              );
+            } else {
+              jitFieldNode.__internalShouldInclude = joinShouldIncludeCompilations(
+                parentFieldNode.__internalShouldInclude ?? [],
+                jitFieldNode.__internalShouldInclude ?? []
+              );
+            }
+          }
+          for (const selection3 of jitFieldNode.selectionSet?.selections ?? []) {
+            stack.push({
+              parentFieldNode: jitFieldNode,
+              selection: selection3,
+              comesFromFragmentSpread: false,
+              parentResponsePath: currentPath
+            });
+          }
+          break;
+        }
+        case import_graphql.Kind.INLINE_FRAGMENT: {
+          for (const subSelection of selection2.selectionSet.selections) {
+            stack.push({
+              parentFieldNode,
+              selection: subSelection,
+              comesFromFragmentSpread: true,
+              parentResponsePath: parentResponsePath2
+            });
+          }
+          break;
+        }
+        case import_graphql.Kind.FRAGMENT_SPREAD: {
+          const fragment = compilationContext.fragments[selection2.name.value];
+          for (const subSelection of fragment.selectionSet.selections) {
+            stack.push({
+              parentFieldNode,
+              selection: subSelection,
+              comesFromFragmentSpread: true,
+              parentResponsePath: parentResponsePath2
+            });
+          }
+        }
+      }
+    }
+  }
+}
+function joinShouldIncludeCompilations(...compilations) {
+  const conditionsSet = /* @__PURE__ */ new Set();
+  for (const conditions of compilations) {
+    for (const condition of conditions) {
+      if (condition !== "true") {
+        conditionsSet.add(condition);
+      }
+    }
+  }
+  return Array.from(conditionsSet);
+}
+function compileSkipInclude(compilationContext, node) {
+  if (node.directives == null || node.directives.length < 1) {
+    return "true";
+  }
+  const { skipValue, includeValue } = compileSkipIncludeDirectiveValues(
+    compilationContext,
+    node
+  );
+  if (skipValue != null && includeValue != null) {
+    return `${skipValue} === false && ${includeValue} === true`;
+  } else if (skipValue != null) {
+    return `(${skipValue} === false)`;
+  } else if (includeValue != null) {
+    return `(${includeValue} === true)`;
+  } else {
+    return `true`;
+  }
+}
+function compileSkipIncludeDirectiveValues(compilationContext, node) {
+  const skipDirective = node.directives?.find(
+    (it) => it.name.value === import_graphql.GraphQLSkipDirective.name
+  );
+  const includeDirective = node.directives?.find(
+    (it) => it.name.value === import_graphql.GraphQLIncludeDirective.name
+  );
+  const skipValue = skipDirective ? compileSkipIncludeDirective(compilationContext, skipDirective) : (
+    // The null here indicates the absense of the directive
+    // which is later used to determine if both skip and include
+    // are present
+    null
+  );
+  const includeValue = includeDirective ? compileSkipIncludeDirective(compilationContext, includeDirective) : (
+    // The null here indicates the absense of the directive
+    // which is later used to determine if both skip and include
+    // are present
+    null
+  );
+  return { skipValue, includeValue };
+}
+function compileSkipIncludeDirective(compilationContext, directive) {
+  const ifNode = directive.arguments?.find((it) => it.name.value === "if");
+  if (ifNode == null) {
+    throw new import_graphql.GraphQLError(
+      `Directive '${directive.name.value}' is missing required arguments: 'if'`,
+      (0, import_compat.getGraphQLErrorOptions)([directive])
+    );
+  }
+  switch (ifNode.value.kind) {
+    case import_graphql.Kind.VARIABLE:
+      validateSkipIncludeVariableType(compilationContext, ifNode.value);
+      return `${import_execution.GLOBAL_VARIABLES_NAME}["${ifNode.value.name.value}"]`;
+    case import_graphql.Kind.BOOLEAN:
+      return `${ifNode.value.value.toString()}`;
+    default:
+      throw new import_graphql.GraphQLError(
+        `Argument 'if' on Directive '${directive.name.value}' has an invalid value (${(0, import_graphql.valueFromASTUntyped)(
+          ifNode.value
+        )}). Expected type 'Boolean!'`,
+        (0, import_compat.getGraphQLErrorOptions)([ifNode])
+      );
+  }
+}
+function validateSkipIncludeVariableType(compilationContext, variable) {
+  const variableDefinition = compilationContext.operation.variableDefinitions?.find(
+    (it) => it.variable.name.value === variable.name.value
+  );
+  if (variableDefinition == null) {
+    throw new import_graphql.GraphQLError(
+      `Variable '${variable.name.value}' is not defined`,
+      (0, import_compat.getGraphQLErrorOptions)([variable])
+    );
+  }
+  if (!// The variable defintion is a Non-nullable Boolean type
+  (variableDefinition.type.kind === import_graphql.Kind.NON_NULL_TYPE && variableDefinition.type.type.kind === import_graphql.Kind.NAMED_TYPE && variableDefinition.type.type.name.value === "Boolean" || // or the variable definition is a nullable Boolean type with a default value
+  variableDefinition.type.kind === import_graphql.Kind.NAMED_TYPE && variableDefinition.type.name.value === "Boolean" && variableDefinition.defaultValue != null)) {
+    throw new import_graphql.GraphQLError(
+      `Variable '${variable.name.value}' of type '${typeNodeToString(
+        variableDefinition.type
+      )}' used in position expecting type 'Boolean!'`,
+      (0, import_compat.getGraphQLErrorOptions)([variableDefinition])
+    );
+  }
+}
+function typeNodeToString(type) {
+  switch (type.kind) {
+    case import_graphql.Kind.NAMED_TYPE:
+      return type.name.value;
+    case import_graphql.Kind.NON_NULL_TYPE:
+      return `${typeNodeToString(type.type)}!`;
+    case import_graphql.Kind.LIST_TYPE:
+      return `[${typeNodeToString(type.type)}]`;
+  }
+}
+function doesFragmentConditionMatch(compilationContext, fragment, type) {
+  const typeConditionNode = fragment.typeCondition;
+  if (!typeConditionNode) {
+    return true;
+  }
+  const conditionalType = (0, import_graphql.typeFromAST)(
+    compilationContext.schema,
+    typeConditionNode
+  );
+  if (conditionalType === type) {
+    return true;
+  }
+  if (!conditionalType) {
+    return false;
+  }
+  if ((0, import_graphql.isAbstractType)(conditionalType)) {
+    return compilationContext.schema.isSubType(conditionalType, type);
+  }
+  return false;
+}
+function getFieldEntryKey(node) {
+  return node.alias ? node.alias.value : node.name.value;
+}
+function collectSubfields(compilationContext, returnType, fieldNodes, parentResponsePath) {
+  let subFieldNodes = /* @__PURE__ */ Object.create(null);
+  const visitedFragmentNames = /* @__PURE__ */ Object.create(null);
+  for (const fieldNode of fieldNodes) {
+    const selectionSet = fieldNode.selectionSet;
+    if (selectionSet) {
+      subFieldNodes = collectFields(
+        compilationContext,
+        returnType,
+        selectionSet,
+        subFieldNodes,
+        visitedFragmentNames,
+        parentResponsePath
+      );
+    }
+  }
+  return subFieldNodes;
+}
+function getArgumentDefs(def, node) {
+  const values = {};
+  const missing = [];
+  const argDefs = def.args;
+  const argNodes = node.arguments || [];
+  const argNodeMap = keyMap(argNodes, (arg) => arg.name.value);
+  for (const argDef of argDefs) {
+    const name = argDef.name;
+    if ((0, import_compat.hasDefaultValue)(argDef)) {
+      values[name] = (0, import_compat.getDefaultValue)(argDef);
+    }
+    const argType = argDef.type;
+    const argumentNode = argNodeMap[name];
+    let hasVariables = false;
+    if (argumentNode && argumentNode.value.kind === import_graphql.Kind.VARIABLE) {
+      hasVariables = true;
+      missing.push({
+        valueNode: argumentNode.value,
+        path: addPath(void 0, name, "literal"),
+        argument: { definition: argDef, node: argumentNode }
+      });
+    } else if (argumentNode) {
+      const coercedValue = valueFromAST(argumentNode.value, argType);
+      if (coercedValue === void 0) {
+        throw new import_graphql.GraphQLError(
+          `Argument "${name}" of type "${argType}" has invalid value ${(0, import_graphql.print)(
+            argumentNode.value
+          )}.`,
+          (0, import_compat.getGraphQLErrorOptions)(argumentNode.value)
+        );
+      }
+      if (isASTValueWithVariables(coercedValue)) {
+        missing.push(
+          ...coercedValue.variables.map(({ valueNode, path }) => ({
+            valueNode,
+            path: addPath(path, name, "literal")
+          }))
+        );
+      }
+      values[name] = coercedValue.value;
+    }
+    if ((0, import_graphql.isNonNullType)(argType) && values[name] === void 0 && !hasVariables) {
+      throw new import_graphql.GraphQLError(
+        argumentNode ? `Argument "${name}" of non-null type "${argType}" must not be null.` : `Argument "${name}" of required type "${argType}" was not provided.`,
+        (0, import_compat.getGraphQLErrorOptions)(node)
+      );
+    }
+  }
+  return { values, missing };
+}
+function isASTValueWithVariables(x) {
+  return !!x.variables;
+}
+function valueFromAST(valueNode, type) {
+  if ((0, import_graphql.isNonNullType)(type)) {
+    if (valueNode.kind === import_graphql.Kind.NULL) {
+      return;
+    }
+    return valueFromAST(valueNode, type.ofType);
+  }
+  if (valueNode.kind === import_graphql.Kind.NULL) {
+    return {
+      value: null
+    };
+  }
+  if (valueNode.kind === import_graphql.Kind.VARIABLE) {
+    return { value: null, variables: [{ valueNode, path: void 0 }] };
+  }
+  if ((0, import_graphql.isListType)(type)) {
+    const itemType = type.ofType;
+    if (valueNode.kind === import_graphql.Kind.LIST) {
+      const coercedValues = [];
+      const variables = [];
+      const itemNodes = valueNode.values;
+      for (let i = 0; i < itemNodes.length; i++) {
+        const itemNode = itemNodes[i];
+        if (itemNode.kind === import_graphql.Kind.VARIABLE) {
+          coercedValues.push(null);
+          variables.push({
+            valueNode: itemNode,
+            path: addPath(void 0, i.toString(), "literal")
+          });
+        } else {
+          const itemValue = valueFromAST(itemNode, itemType);
+          if (!itemValue) {
+            return;
+          }
+          coercedValues.push(itemValue.value);
+          if (isASTValueWithVariables(itemValue)) {
+            variables.push(
+              ...itemValue.variables.map(({ valueNode: valueNode2, path }) => ({
+                valueNode: valueNode2,
+                path: addPath(path, i.toString(), "literal")
+              }))
+            );
+          }
+        }
+      }
+      return { value: coercedValues, variables };
+    }
+    const coercedValue = valueFromAST(valueNode, itemType);
+    if (coercedValue === void 0) {
+      return;
+    }
+    if (isASTValueWithVariables(coercedValue)) {
+      return {
+        value: [coercedValue.value],
+        variables: coercedValue.variables.map(({ valueNode: valueNode2, path }) => ({
+          valueNode: valueNode2,
+          path: addPath(path, "0", "literal")
+        }))
+      };
+    }
+    return { value: [coercedValue.value] };
+  }
+  if ((0, import_graphql.isInputObjectType)(type)) {
+    if (valueNode.kind !== import_graphql.Kind.OBJECT) {
+      return;
+    }
+    const coercedObj = /* @__PURE__ */ Object.create(null);
+    const variables = [];
+    const fieldNodes = keyMap(valueNode.fields, (field) => field.name.value);
+    const fields = Object.values(type.getFields());
+    for (const field of fields) {
+      if ((0, import_compat.hasDefaultValue)(field)) {
+        coercedObj[field.name] = (0, import_compat.getDefaultValue)(field);
+      }
+      const fieldNode = fieldNodes[field.name];
+      if (!fieldNode) {
+        continue;
+      }
+      const fieldValue = valueFromAST(fieldNode.value, field.type);
+      if (!fieldValue) {
+        return;
+      }
+      if (isASTValueWithVariables(fieldValue)) {
+        variables.push(
+          ...fieldValue.variables.map(({ valueNode: valueNode2, path }) => ({
+            valueNode: valueNode2,
+            path: addPath(path, field.name, "literal")
+          }))
+        );
+      }
+      coercedObj[field.name] = fieldValue.value;
+    }
+    return { value: coercedObj, variables };
+  }
+  if ((0, import_graphql.isEnumType)(type)) {
+    if (valueNode.kind !== import_graphql.Kind.ENUM) {
+      return;
+    }
+    const enumValue = type.getValue(valueNode.value);
+    if (!enumValue) {
+      return;
+    }
+    return { value: enumValue.value };
+  }
+  if ((0, import_graphql.isScalarType)(type)) {
+    let result;
+    try {
+      result = (0, import_compat.coerceInputLiteral)(type, valueNode);
+    } catch (error) {
+      return;
+    }
+    if (isInvalid(result)) {
+      return;
+    }
+    return { value: result };
+  }
+  throw new Error(`Unexpected input type: "${inspect(type)}".`);
+}
+function keyMap(list, keyFn) {
+  return list.reduce(
+    // eslint-disable-next-line no-sequences
+    (map, item) => (map[keyFn(item)] = item, map),
+    /* @__PURE__ */ Object.create(null)
+  );
+}
+function computeLocations(nodes) {
+  return nodes.reduce((list, node) => {
+    if (node.loc) {
+      list.push(getLocation(node.loc));
+    }
+    return list;
+  }, []);
+}
+function getLocation(loc) {
+  return {
+    line: loc.startToken.line,
+    column: loc.startToken.column
+  };
+}
+function addPath(responsePath, key, type = "literal") {
+  return { prev: responsePath, key, type };
+}
+function flattenPath(path) {
+  const flattened = [];
+  let curr = path;
+  while (curr) {
+    flattened.push({ key: curr.key, type: curr.type });
+    curr = curr.prev;
+  }
+  return flattened;
+}
+function serializeObjectPathForSkipInclude(path) {
+  let serialized = "";
+  let curr = path;
+  while (curr) {
+    if (curr.type === "literal") {
+      serialized = joinSkipIncludePath(curr.key, serialized);
+    }
+    curr = curr.prev;
+  }
+  return serialized;
+}
+function joinSkipIncludePath(a, b) {
+  if (a) {
+    if (b) {
+      return `${a}.${b}`;
+    }
+    return a;
+  }
+  return b;
+}
+function isInvalid(value) {
+  return value === void 0 || value !== value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addPath,
+  collectFields,
+  collectSubfields,
+  computeLocations,
+  flattenPath,
+  getArgumentDefs,
+  joinSkipIncludePath,
+  resolveFieldDef,
+  serializeObjectPathForSkipInclude,
+  valueFromAST
+});
+//# sourceMappingURL=ast.js.map