houdini 0.19.4 → 1.0.0-next.1

package/build/codegen-esm/index.js

@@ -9759,7 +9759,7 @@ var require_graphql = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.graphql = graphql28;
+    exports.graphql = graphql27;
     exports.graphqlSync = graphqlSync;
     var _isPromise = _interopRequireDefault(require_isPromise());
     var _parser = require_parser();
@@ -9769,7 +9769,7 @@ var require_graphql = __commonJS({
     function _interopRequireDefault(obj) {
       return obj && obj.__esModule ? obj : { default: obj };
     }
-    function graphql28(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) {
+    function graphql27(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) {
       var _arguments = arguments;
       return new Promise(function(resolve2) {
         return resolve2(
@@ -14714,9 +14714,9 @@ var require_graphql2 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/minimatch@5.1.1/node_modules/minimatch/lib/path.js
+// ../../node_modules/.pnpm/minimatch@5.1.2/node_modules/minimatch/lib/path.js
 var require_path = __commonJS({
-  "../../node_modules/.pnpm/minimatch@5.1.1/node_modules/minimatch/lib/path.js"(exports, module) {
+  "../../node_modules/.pnpm/minimatch@5.1.2/node_modules/minimatch/lib/path.js"(exports, module) {
     var isWindows = typeof process === "object" && process && process.platform === "win32";
     module.exports = isWindows ? { sep: "\\" } : { sep: "/" };
   }
@@ -14933,9 +14933,9 @@ var require_brace_expansion = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/minimatch@5.1.1/node_modules/minimatch/minimatch.js
+// ../../node_modules/.pnpm/minimatch@5.1.2/node_modules/minimatch/minimatch.js
 var require_minimatch = __commonJS({
-  "../../node_modules/.pnpm/minimatch@5.1.1/node_modules/minimatch/minimatch.js"(exports, module) {
+  "../../node_modules/.pnpm/minimatch@5.1.2/node_modules/minimatch/minimatch.js"(exports, module) {
     var minimatch2 = module.exports = (p, pattern, options = {}) => {
       assertValidPattern(pattern);
       if (!options.nocomment && pattern.charAt(0) === "#") {
@@ -15021,7 +15021,9 @@ var require_minimatch = __commonJS({
       return list;
     };
     var globUnescape = (s) => s.replace(/\\(.)/g, "$1");
+    var charUnescape = (s) => s.replace(/\\([^-\]])/g, "$1");
     var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var braExpEscape = (s) => s.replace(/[[\]\\]/g, "\\$&");
     var Minimatch = class {
       constructor(pattern, options) {
         assertValidPattern(pattern);
@@ -15213,6 +15215,10 @@ var require_minimatch = __commonJS({
               return false;
             }
             case "\\":
+              if (inClass && pattern.charAt(i + 1) === "-") {
+                re += c;
+                continue;
+              }
               clearStateChar();
               escaping = true;
               continue;
@@ -15295,17 +15301,13 @@ var require_minimatch = __commonJS({
               }
               cs = pattern.substring(classStart + 1, i);
               try {
-                RegExp("[" + cs + "]");
+                RegExp("[" + braExpEscape(charUnescape(cs)) + "]");
+                re += c;
               } catch (er) {
-                sp = this.parse(cs, SUBPARSE);
-                re = re.substring(0, reClassStart) + "\\[" + sp[0] + "\\]";
-                hasMagic = hasMagic || sp[1];
-                inClass = false;
-                continue;
+                re = re.substring(0, reClassStart) + "(?:$.)";
               }
               hasMagic = true;
               inClass = false;
-              re += c;
               continue;
             default:
               clearStateChar();
@@ -23132,9 +23134,9 @@ var require_lib2 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@babel+parser@7.20.5/node_modules/@babel/parser/lib/index.js
+// ../../node_modules/.pnpm/@babel+parser@7.20.7/node_modules/@babel/parser/lib/index.js
 var require_lib3 = __commonJS({
-  "../../node_modules/.pnpm/@babel+parser@7.20.5/node_modules/@babel/parser/lib/index.js"(exports) {
+  "../../node_modules/.pnpm/@babel+parser@7.20.7/node_modules/@babel/parser/lib/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     function _objectWithoutPropertiesLoose(source, excluded) {
@@ -23250,9 +23252,9 @@ var require_lib3 = __commonJS({
       AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
       AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
       AwaitNotInAsyncFunction: "'await' is only allowed within async functions.",
-      BadGetterArity: "A 'get' accesor must not have any formal parameters.",
-      BadSetterArity: "A 'set' accesor must have exactly one formal parameter.",
-      BadSetterRestParameter: "A 'set' accesor function argument must not be a rest parameter.",
+      BadGetterArity: "A 'get' accessor must not have any formal parameters.",
+      BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
+      BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
       ConstructorClassField: "Classes may not have a field named 'constructor'.",
       ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
       ConstructorIsAccessor: "Class constructor may not be an accessor.",
@@ -26686,7 +26688,7 @@ var require_lib3 = __commonJS({
         }
         this.parser.raise(toParseError, origin);
       }
-      recordArrowParemeterBindingError(error, {
+      recordArrowParameterBindingError(error, {
         at: node
       }) {
         const {
@@ -30445,6 +30447,7 @@ var require_lib3 = __commonJS({
       }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
       AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
       AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
+      AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
       ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
       ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
       ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
@@ -32407,8 +32410,12 @@ var require_lib3 = __commonJS({
           node.typeParameters = typeParameters;
       }
       parseClassPropertyAnnotation(node) {
-        if (!node.optional && this.eat(35)) {
-          node.definite = true;
+        if (!node.optional) {
+          if (this.eat(35)) {
+            node.definite = true;
+          } else if (this.eat(17)) {
+            node.optional = true;
+          }
         }
         const type = this.tsTryParseTypeAnnotation();
         if (type)
@@ -32447,6 +32454,15 @@ var require_lib3 = __commonJS({
         this.parseClassPropertyAnnotation(node);
         return super.parseClassPrivateProperty(node);
       }
+      parseClassAccessorProperty(node) {
+        this.parseClassPropertyAnnotation(node);
+        if (node.optional) {
+          this.raise(TSErrors.AccessorCannotBeOptional, {
+            at: node
+          });
+        }
+        return super.parseClassAccessorProperty(node);
+      }
       pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
         const typeParameters = this.tsTryParseTypeParameters();
         if (typeParameters && isConstructor) {
@@ -32657,7 +32673,7 @@ var require_lib3 = __commonJS({
           case "TSNonNullExpression":
           case "TSTypeAssertion":
             if (isLHS) {
-              this.expressionScope.recordArrowParemeterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
+              this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
                 at: node
               });
             } else {
@@ -33364,7 +33380,7 @@ var require_lib3 = __commonJS({
           parenthesized = unwrapParenthesizedExpression(node);
           if (isLHS) {
             if (parenthesized.type === "Identifier") {
-              this.expressionScope.recordArrowParemeterBindingError(Errors.InvalidParenthesizedAssignment, {
+              this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
                 at: node
               });
             } else if (parenthesized.type !== "MemberExpression") {
@@ -53922,7 +53938,7 @@ var require_main2 = __commonJS({
 });
 
 // src/codegen/index.ts
-var graphql27 = __toESM(require_graphql2(), 1);
+var graphql26 = __toESM(require_graphql2(), 1);
 
 // src/lib/pipeline.ts
 async function runPipeline(config2, pipeline, target) {
@@ -56079,6 +56095,60 @@ function definitionFromAncestors(ancestors) {
   }
   return definition;
 }
+function unwrapType(config2, type, wrappers = []) {
+  if (type.kind === "NonNullType") {
+    return unwrapType(config2, type.type, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (type instanceof graphql.GraphQLNonNull) {
+    return unwrapType(config2, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (wrappers[0] !== TypeWrapper.NonNull) {
+    wrappers.unshift(TypeWrapper.Nullable);
+  }
+  if (type.kind === "ListType") {
+    return unwrapType(config2, type.type, [TypeWrapper.List, ...wrappers]);
+  }
+  if (type instanceof graphql.GraphQLList) {
+    return unwrapType(config2, type.ofType, [TypeWrapper.List, ...wrappers]);
+  }
+  const namedType = config2.schema.getType(type.name.value || type.name);
+  if (!namedType) {
+    throw new Error("Could not unwrap type: " + JSON.stringify(type));
+  }
+  return { type: namedType, wrappers };
+}
+function wrapType({
+  type,
+  wrappers
+}) {
+  const head = wrappers[0];
+  const tail = wrappers.slice(1);
+  let kind = graphql.Kind.NAMED_TYPE;
+  if (head === TypeWrapper.List) {
+    kind = graphql.Kind.LIST_TYPE;
+  } else if (head === TypeWrapper.NonNull) {
+    kind = graphql.Kind.NON_NULL_TYPE;
+  }
+  if (kind === "NamedType") {
+    return {
+      kind,
+      name: {
+        kind: graphql.Kind.NAME,
+        value: type.name
+      }
+    };
+  }
+  return {
+    kind,
+    type: wrapType({ type, wrappers: tail })
+  };
+}
+var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
+  TypeWrapper2["Nullable"] = "Nullable";
+  TypeWrapper2["List"] = "List";
+  TypeWrapper2["NonNull"] = "NonNull";
+  return TypeWrapper2;
+})(TypeWrapper || {});
 
 // src/lib/parse.ts
 var import_parser = __toESM(require_lib3(), 1);
@@ -56323,7 +56393,7 @@ async function find_graphql(config2, parsedScript, walker) {
 }
 
 // src/codegen/generators/artifacts/index.ts
-var graphql12 = __toESM(require_graphql2(), 1);
+var graphql11 = __toESM(require_graphql2(), 1);
 var recast5 = __toESM(require_main2(), 1);
 
 // src/codegen/utils/commonjs.ts
@@ -56499,63 +56569,6 @@ var FieldCollection = class {
   }
 };
 
-// src/codegen/utils/graphql.ts
-var graphql3 = __toESM(require_graphql2(), 1);
-function unwrapType(config2, type, wrappers = []) {
-  if (type.kind === "NonNullType") {
-    return unwrapType(config2, type.type, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (type instanceof graphql3.GraphQLNonNull) {
-    return unwrapType(config2, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (wrappers[0] !== TypeWrapper.NonNull) {
-    wrappers.unshift(TypeWrapper.Nullable);
-  }
-  if (type.kind === "ListType") {
-    return unwrapType(config2, type.type, [TypeWrapper.List, ...wrappers]);
-  }
-  if (type instanceof graphql3.GraphQLList) {
-    return unwrapType(config2, type.ofType, [TypeWrapper.List, ...wrappers]);
-  }
-  const namedType = config2.schema.getType(type.name.value || type.name);
-  if (!namedType) {
-    throw new Error("Could not unwrap type: " + JSON.stringify(type));
-  }
-  return { type: namedType, wrappers };
-}
-function wrapType({
-  type,
-  wrappers
-}) {
-  const head = wrappers[0];
-  const tail = wrappers.slice(1);
-  let kind = graphql3.Kind.NAMED_TYPE;
-  if (head === TypeWrapper.List) {
-    kind = graphql3.Kind.LIST_TYPE;
-  } else if (head === TypeWrapper.NonNull) {
-    kind = graphql3.Kind.NON_NULL_TYPE;
-  }
-  if (kind === "NamedType") {
-    return {
-      kind,
-      name: {
-        kind: graphql3.Kind.NAME,
-        value: type.name
-      }
-    };
-  }
-  return {
-    kind,
-    type: wrapType({ type, wrappers: tail })
-  };
-}
-var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
-  TypeWrapper2["Nullable"] = "Nullable";
-  TypeWrapper2["List"] = "List";
-  TypeWrapper2["NonNull"] = "NonNull";
-  return TypeWrapper2;
-})(TypeWrapper || {});
-
 // src/codegen/utils/moduleExport.ts
 var recast2 = __toESM(require_main2(), 1);
 var AST2 = recast2.types.builders;
@@ -56642,7 +56655,7 @@ ${exportDefaultFrom(`./${doc.name}`, doc.name)}`,
 }
 
 // src/codegen/generators/artifacts/inputs.ts
-var graphql4 = __toESM(require_graphql2(), 1);
+var graphql3 = __toESM(require_graphql2(), 1);
 var recast3 = __toESM(require_main2(), 1);
 var AST3 = recast3.types.builders;
 function inputObject(config2, inputs) {
@@ -56667,10 +56680,10 @@ function walkInputs(config2, visitedTypes, inputObj, rootType) {
   if (visitedTypes.has(type.name)) {
     return;
   }
-  if (graphql4.isEnumType(type) || graphql4.isScalarType(type)) {
+  if (graphql3.isEnumType(type) || graphql3.isScalarType(type)) {
     return;
   }
-  if (graphql4.isUnionType(type)) {
+  if (graphql3.isUnionType(type)) {
     return;
   }
   visitedTypes.add(type.name);
@@ -56688,10 +56701,10 @@ function walkInputs(config2, visitedTypes, inputObj, rootType) {
 }
 
 // src/codegen/generators/artifacts/operations.ts
-var graphql6 = __toESM(require_graphql2(), 1);
+var graphql5 = __toESM(require_graphql2(), 1);
 
 // src/codegen/generators/artifacts/utils.ts
-var graphql5 = __toESM(require_graphql2(), 1);
+var graphql4 = __toESM(require_graphql2(), 1);
 var recast4 = __toESM(require_main2(), 1);
 var AST4 = recast4.types.builders;
 function serializeValue(value) {
@@ -56743,19 +56756,19 @@ function deepMerge(filepath, ...targets) {
 function convertValue(config2, val) {
   let value;
   let kind;
-  if (val.kind === graphql5.Kind.INT) {
+  if (val.kind === graphql4.Kind.INT) {
     value = parseInt(val.value, 10);
     kind = "Int";
-  } else if (val.kind === graphql5.Kind.FLOAT) {
+  } else if (val.kind === graphql4.Kind.FLOAT) {
     value = parseFloat(val.value);
     kind = "Float";
-  } else if (val.kind === graphql5.Kind.BOOLEAN) {
+  } else if (val.kind === graphql4.Kind.BOOLEAN) {
     value = val.value;
     kind = "Boolean";
-  } else if (val.kind === graphql5.Kind.VARIABLE) {
+  } else if (val.kind === graphql4.Kind.VARIABLE) {
     value = val.name.value;
     kind = "Variable";
-  } else if (val.kind === graphql5.Kind.STRING) {
+  } else if (val.kind === graphql4.Kind.STRING) {
     value = val.value;
     kind = "String";
   }
@@ -56768,7 +56781,7 @@ function operationsByPath(config2, filepath, definition, filterTypes) {
     return {};
   }
   const pathOperations = {};
-  graphql6.visit(definition, {
+  graphql5.visit(definition, {
     FragmentSpread(node, _, __, ___, ancestors) {
       if (!config2.isListFragment(node.name.value)) {
         return;
@@ -56927,7 +56940,7 @@ function ancestorKey(ancestors) {
 }
 
 // src/codegen/generators/artifacts/selection.ts
-var graphql11 = __toESM(require_graphql2(), 1);
+var graphql10 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.pnpm/@kitql+helper@0.5.0/node_modules/@kitql/helper/index.mjs
 var config = {
@@ -56967,16 +56980,16 @@ function logYellow(str) {
 }
 
 // src/codegen/transforms/list.ts
-var graphql9 = __toESM(require_graphql2(), 1);
+var graphql8 = __toESM(require_graphql2(), 1);
 
 // src/codegen/utils/objectIdentificationSelection.ts
-var graphql7 = __toESM(require_graphql2(), 1);
+var graphql6 = __toESM(require_graphql2(), 1);
 var objectIdentificationSelection = (config2, type) => {
   return config2.keyFieldsForType(type.name).map((key) => {
     return {
-      kind: graphql7.Kind.FIELD,
+      kind: graphql6.Kind.FIELD,
       name: {
-        kind: graphql7.Kind.NAME,
+        kind: graphql6.Kind.NAME,
         value: key
       }
     };
@@ -56984,7 +56997,7 @@ var objectIdentificationSelection = (config2, type) => {
 };
 
 // src/codegen/transforms/paginate.ts
-var graphql8 = __toESM(require_graphql2(), 1);
+var graphql7 = __toESM(require_graphql2(), 1);
 async function paginate(config2, documents) {
   const newDocs = [];
   for (const doc of documents) {
@@ -57017,7 +57030,7 @@ async function paginate(config2, documents) {
     };
     let cursorType = "String";
     let paginationPath = [];
-    doc.document = graphql8.visit(doc.document, {
+    doc.document = graphql7.visit(doc.document, {
       Field(node, _, __, ___, ancestors) {
         const paginateDirective = node.directives?.find(
           (directive) => directive.name.value === config2.paginateDirective
@@ -57044,7 +57057,7 @@ async function paginate(config2, documents) {
         flags.offset.enabled = offsetPagination;
         flags.limit.enabled = offsetPagination;
         paginationPath = ancestors.filter(
-          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql8.Kind.FIELD
+          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql7.Kind.FIELD
         ).concat(node).map((field) => field.alias?.value || field.name.value);
         return {
           ...node,
@@ -57065,7 +57078,7 @@ async function paginate(config2, documents) {
         refetchUpdate = "prepend" /* prepend */;
       }
       let fragment = "";
-      doc.document = graphql8.visit(doc.document, {
+      doc.document = graphql7.visit(doc.document, {
         OperationDefinition(node) {
           if (node.operation !== "query") {
             throw new HoudiniError({
@@ -57119,9 +57132,9 @@ async function paginate(config2, documents) {
               directives: [
                 ...node.directives || [],
                 {
-                  kind: graphql8.Kind.DIRECTIVE,
+                  kind: graphql7.Kind.DIRECTIVE,
                   name: {
-                    kind: graphql8.Kind.NAME,
+                    kind: graphql7.Kind.NAME,
                     value: config2.argumentsDirective
                   }
                 }
@@ -57184,16 +57197,16 @@ async function paginate(config2, documents) {
       const paginationArgs = Object.entries(flags).filter(([_, { enabled }]) => enabled).map(([key, value]) => ({ name: key, ...value }));
       const fragmentSpreadSelection = [
         {
-          kind: graphql8.Kind.FRAGMENT_SPREAD,
+          kind: graphql7.Kind.FRAGMENT_SPREAD,
           name: {
-            kind: graphql8.Kind.NAME,
+            kind: graphql7.Kind.NAME,
             value: fragmentName
           },
           directives: [
             {
-              kind: graphql8.Kind.DIRECTIVE,
+              kind: graphql7.Kind.DIRECTIVE,
               name: {
-                kind: graphql8.Kind.NAME,
+                kind: graphql7.Kind.NAME,
                 value: config2.withDirective
               },
               ["arguments"]: paginationArgs.map(
@@ -57221,29 +57234,29 @@ async function paginate(config2, documents) {
       });
       const typeConfig = config2.typeConfig?.[fragment];
       const queryDoc = {
-        kind: graphql8.Kind.DOCUMENT,
+        kind: graphql7.Kind.DOCUMENT,
         definitions: [
           {
-            kind: graphql8.Kind.OPERATION_DEFINITION,
+            kind: graphql7.Kind.OPERATION_DEFINITION,
             name: {
-              kind: graphql8.Kind.NAME,
+              kind: graphql7.Kind.NAME,
               value: refetchQueryName
             },
             operation: "query",
             variableDefinitions: paginationArgs.map(
               (arg) => ({
-                kind: graphql8.Kind.VARIABLE_DEFINITION,
+                kind: graphql7.Kind.VARIABLE_DEFINITION,
                 type: {
-                  kind: graphql8.Kind.NAMED_TYPE,
+                  kind: graphql7.Kind.NAMED_TYPE,
                   name: {
-                    kind: graphql8.Kind.NAME,
+                    kind: graphql7.Kind.NAME,
                     value: arg.type
                   }
                 },
                 variable: {
-                  kind: graphql8.Kind.VARIABLE,
+                  kind: graphql7.Kind.VARIABLE,
                   name: {
-                    kind: graphql8.Kind.NAME,
+                    kind: graphql7.Kind.NAME,
                     value: arg.name
                   }
                 },
@@ -57255,12 +57268,12 @@ async function paginate(config2, documents) {
             ).concat(
               !nodeQuery ? [] : keys.map(
                 (key) => ({
-                  kind: graphql8.Kind.VARIABLE_DEFINITION,
+                  kind: graphql7.Kind.VARIABLE_DEFINITION,
                   type: key.type,
                   variable: {
-                    kind: graphql8.Kind.VARIABLE,
+                    kind: graphql7.Kind.VARIABLE,
                     name: {
-                      kind: graphql8.Kind.NAME,
+                      kind: graphql7.Kind.NAME,
                       value: key.name
                     }
                   }
@@ -57268,42 +57281,42 @@ async function paginate(config2, documents) {
               )
             ),
             selectionSet: {
-              kind: graphql8.Kind.SELECTION_SET,
+              kind: graphql7.Kind.SELECTION_SET,
               selections: !nodeQuery ? fragmentSpreadSelection : [
                 {
-                  kind: graphql8.Kind.FIELD,
+                  kind: graphql7.Kind.FIELD,
                   name: {
-                    kind: graphql8.Kind.NAME,
+                    kind: graphql7.Kind.NAME,
                     value: typeConfig?.resolve?.queryField || "node"
                   },
                   ["arguments"]: keys.map((key) => ({
-                    kind: graphql8.Kind.ARGUMENT,
+                    kind: graphql7.Kind.ARGUMENT,
                     name: {
-                      kind: graphql8.Kind.NAME,
+                      kind: graphql7.Kind.NAME,
                       value: key.name
                     },
                     value: {
-                      kind: graphql8.Kind.VARIABLE,
+                      kind: graphql7.Kind.VARIABLE,
                       name: {
-                        kind: graphql8.Kind.NAME,
+                        kind: graphql7.Kind.NAME,
                         value: key.name
                       }
                     }
                   })),
                   selectionSet: {
-                    kind: graphql8.Kind.SELECTION_SET,
+                    kind: graphql7.Kind.SELECTION_SET,
                     selections: [
                       {
-                        kind: graphql8.Kind.FIELD,
+                        kind: graphql7.Kind.FIELD,
                         name: {
-                          kind: graphql8.Kind.NAME,
+                          kind: graphql7.Kind.NAME,
                           value: "__typename"
                         }
                       },
                       ...(typeConfig?.keys || ["id"]).map((key) => ({
-                        kind: graphql8.Kind.FIELD,
+                        kind: graphql7.Kind.FIELD,
                         name: {
-                          kind: graphql8.Kind.NAME,
+                          kind: graphql7.Kind.NAME,
                           value: key
                         }
                       })),
@@ -57365,15 +57378,15 @@ function replaceArgumentsWithVariables(args, flags) {
 }
 function variableAsArgument(name2, variable) {
   return {
-    kind: graphql8.Kind.ARGUMENT,
+    kind: graphql7.Kind.ARGUMENT,
     name: {
-      kind: graphql8.Kind.NAME,
+      kind: graphql7.Kind.NAME,
       value: name2
     },
     value: {
-      kind: graphql8.Kind.VARIABLE,
+      kind: graphql7.Kind.VARIABLE,
       name: {
-        kind: graphql8.Kind.NAME,
+        kind: graphql7.Kind.NAME,
         value: variable ?? name2
       }
     }
@@ -57381,18 +57394,18 @@ function variableAsArgument(name2, variable) {
 }
 function staticVariableDefinition(name2, type, defaultValue, variableName) {
   return {
-    kind: graphql8.Kind.VARIABLE_DEFINITION,
+    kind: graphql7.Kind.VARIABLE_DEFINITION,
     type: {
-      kind: graphql8.Kind.NAMED_TYPE,
+      kind: graphql7.Kind.NAMED_TYPE,
       name: {
-        kind: graphql8.Kind.NAME,
+        kind: graphql7.Kind.NAME,
         value: type
       }
     },
     variable: {
-      kind: graphql8.Kind.VARIABLE,
+      kind: graphql7.Kind.VARIABLE,
       name: {
-        kind: graphql8.Kind.NAME,
+        kind: graphql7.Kind.NAME,
         value: variableName ?? name2
       }
     },
@@ -57404,9 +57417,9 @@ function staticVariableDefinition(name2, type, defaultValue, variableName) {
 }
 function argumentNode(name2, value) {
   return {
-    kind: graphql8.Kind.ARGUMENT,
+    kind: graphql7.Kind.ARGUMENT,
     name: {
-      kind: graphql8.Kind.NAME,
+      kind: graphql7.Kind.NAME,
       value: name2
     },
     value: objectNode(value)
@@ -57414,16 +57427,16 @@ function argumentNode(name2, value) {
 }
 function objectNode([type, defaultValue]) {
   const node = {
-    kind: graphql8.Kind.OBJECT,
+    kind: graphql7.Kind.OBJECT,
     fields: [
       {
-        kind: graphql8.Kind.OBJECT_FIELD,
+        kind: graphql7.Kind.OBJECT_FIELD,
         name: {
-          kind: graphql8.Kind.NAME,
+          kind: graphql7.Kind.NAME,
           value: "type"
         },
         value: {
-          kind: graphql8.Kind.STRING,
+          kind: graphql7.Kind.STRING,
           value: type
         }
       }
@@ -57431,8 +57444,8 @@ function objectNode([type, defaultValue]) {
   };
   if (defaultValue) {
     node.fields.push({
-      kind: graphql8.Kind.OBJECT_FIELD,
-      name: { kind: graphql8.Kind.NAME, value: "default" },
+      kind: graphql7.Kind.OBJECT_FIELD,
+      name: { kind: graphql7.Kind.NAME, value: "default" },
       value: {
         kind: typeof defaultValue === "number" ? "IntValue" : "StringValue",
         value: defaultValue.toString()
@@ -57443,34 +57456,34 @@ function objectNode([type, defaultValue]) {
 }
 var pageInfoSelection = [
   {
-    kind: graphql8.Kind.FIELD,
+    kind: graphql7.Kind.FIELD,
     name: {
-      kind: graphql8.Kind.NAME,
+      kind: graphql7.Kind.NAME,
       value: "edges"
     },
     selectionSet: {
-      kind: graphql8.Kind.SELECTION_SET,
+      kind: graphql7.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql8.Kind.FIELD,
+          kind: graphql7.Kind.FIELD,
           name: {
-            kind: graphql8.Kind.NAME,
+            kind: graphql7.Kind.NAME,
             value: "cursor"
           }
         },
         {
-          kind: graphql8.Kind.FIELD,
+          kind: graphql7.Kind.FIELD,
           name: {
-            kind: graphql8.Kind.NAME,
+            kind: graphql7.Kind.NAME,
             value: "node"
           },
           selectionSet: {
-            kind: graphql8.Kind.SELECTION_SET,
+            kind: graphql7.Kind.SELECTION_SET,
             selections: [
               {
-                kind: graphql8.Kind.FIELD,
+                kind: graphql7.Kind.FIELD,
                 name: {
-                  kind: graphql8.Kind.NAME,
+                  kind: graphql7.Kind.NAME,
                   value: "__typename"
                 }
               }
@@ -57481,39 +57494,39 @@ var pageInfoSelection = [
     }
   },
   {
-    kind: graphql8.Kind.FIELD,
+    kind: graphql7.Kind.FIELD,
     name: {
-      kind: graphql8.Kind.NAME,
+      kind: graphql7.Kind.NAME,
       value: "pageInfo"
     },
     selectionSet: {
-      kind: graphql8.Kind.SELECTION_SET,
+      kind: graphql7.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql8.Kind.FIELD,
+          kind: graphql7.Kind.FIELD,
           name: {
-            kind: graphql8.Kind.NAME,
+            kind: graphql7.Kind.NAME,
             value: "hasPreviousPage"
           }
         },
         {
-          kind: graphql8.Kind.FIELD,
+          kind: graphql7.Kind.FIELD,
           name: {
-            kind: graphql8.Kind.NAME,
+            kind: graphql7.Kind.NAME,
             value: "hasNextPage"
           }
         },
         {
-          kind: graphql8.Kind.FIELD,
+          kind: graphql7.Kind.FIELD,
           name: {
-            kind: graphql8.Kind.NAME,
+            kind: graphql7.Kind.NAME,
             value: "startCursor"
           }
         },
         {
-          kind: graphql8.Kind.FIELD,
+          kind: graphql7.Kind.FIELD,
           name: {
-            kind: graphql8.Kind.NAME,
+            kind: graphql7.Kind.NAME,
             value: "endCursor"
           }
         }
@@ -57527,15 +57540,15 @@ async function addListFragments(config2, documents) {
   const lists = {};
   const errors = [];
   for (const doc of documents) {
-    doc.document = graphql9.visit(doc.document, {
+    doc.document = graphql8.visit(doc.document, {
       Directive(node, key, parent, path2, ancestors) {
         if ([config2.listDirective, config2.paginateDirective].includes(node.name.value)) {
           const nameArg = node.arguments?.find((arg) => arg.name.value === "name");
           let error = {
-            ...new graphql9.GraphQLError(
+            ...new graphql8.GraphQLError(
               "",
               node,
-              new graphql9.Source(""),
+              new graphql8.Source(""),
               node.loc ? [node.loc.start, node.loc.end] : null,
               path2
             ),
@@ -57587,7 +57600,7 @@ async function addListFragments(config2, documents) {
                 {
                   kind: "Argument",
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: "connection"
                   },
                   value: {
@@ -57637,7 +57650,7 @@ async function addListFragments(config2, documents) {
   const validDeletes = [
     ...new Set(
       Object.values(lists).map(({ type }) => {
-        if (!(type instanceof graphql9.GraphQLObjectType)) {
+        if (!(type instanceof graphql8.GraphQLObjectType)) {
           return "";
         }
         if (config2.keyFieldsForType(type.name).length !== 1) {
@@ -57651,7 +57664,7 @@ async function addListFragments(config2, documents) {
     return;
   }
   const generatedDoc = {
-    kind: graphql9.Kind.DOCUMENT,
+    kind: graphql8.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
       ([name2, { selection: selection2, type }]) => {
         const schemaType = config2.schema.getType(type.name);
@@ -57659,7 +57672,7 @@ async function addListFragments(config2, documents) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
-          kind: graphql9.Kind.SELECTION_SET,
+          kind: graphql8.Kind.SELECTION_SET,
           selections: [...selection2.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
@@ -57674,14 +57687,14 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listInsertFragment(name2),
-              kind: graphql9.Kind.NAME
+              kind: graphql8.Kind.NAME
             },
-            kind: graphql9.Kind.FRAGMENT_DEFINITION,
+            kind: graphql8.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql9.Kind.NAMED_TYPE,
+              kind: graphql8.Kind.NAMED_TYPE,
               name: {
-                kind: graphql9.Kind.NAME,
+                kind: graphql8.Kind.NAME,
                 value: type.name
               }
             }
@@ -57689,32 +57702,32 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listToggleFragment(name2),
-              kind: graphql9.Kind.NAME
+              kind: graphql8.Kind.NAME
             },
-            kind: graphql9.Kind.FRAGMENT_DEFINITION,
+            kind: graphql8.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql9.Kind.NAMED_TYPE,
+              kind: graphql8.Kind.NAMED_TYPE,
               name: {
-                kind: graphql9.Kind.NAME,
+                kind: graphql8.Kind.NAME,
                 value: type.name
               }
             }
           },
           {
-            kind: graphql9.Kind.FRAGMENT_DEFINITION,
+            kind: graphql8.Kind.FRAGMENT_DEFINITION,
             name: {
               value: config2.listRemoveFragment(name2),
-              kind: graphql9.Kind.NAME
+              kind: graphql8.Kind.NAME
             },
             selectionSet: {
-              kind: graphql9.Kind.SELECTION_SET,
+              kind: graphql8.Kind.SELECTION_SET,
               selections: [...objectIdentificationSelection(config2, type)]
             },
             typeCondition: {
-              kind: graphql9.Kind.NAMED_TYPE,
+              kind: graphql8.Kind.NAMED_TYPE,
               name: {
-                kind: graphql9.Kind.NAME,
+                kind: graphql8.Kind.NAME,
                 value: type.name
               }
             }
@@ -57723,14 +57736,14 @@ async function addListFragments(config2, documents) {
       }
     ).concat(
       ...validDeletes.map((typeName) => ({
-        kind: graphql9.Kind.DIRECTIVE_DEFINITION,
+        kind: graphql8.Kind.DIRECTIVE_DEFINITION,
         name: {
-          kind: graphql9.Kind.NAME,
+          kind: graphql8.Kind.NAME,
           value: config2.listDeleteDirective(typeName)
         },
         locations: [
           {
-            kind: graphql9.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "FIELD"
           }
         ],
@@ -57738,8 +57751,8 @@ async function addListFragments(config2, documents) {
       }))
     )
   };
-  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql9.print).join("\n\n");
-  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql9.print).join("\n\n");
+  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql8.print).join("\n\n");
+  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql8.print).join("\n\n");
   documents.push({
     name: "generated::lists",
     kind: "HoudiniFragment" /* Fragment */,
@@ -57824,11 +57837,11 @@ var nodeNotDefinedMessage = (config2) => `Looks like you are trying to use the $
 For more information, visit this link: ${siteURL}/guides/pagination`;
 
 // src/codegen/generators/artifacts/fieldKey.ts
-var graphql10 = __toESM(require_graphql2(), 1);
+var graphql9 = __toESM(require_graphql2(), 1);
 function fieldKey(config2, field) {
   const attributeName = field.alias?.value || field.name.value;
-  const printed = graphql10.print(field);
-  const secondParse = graphql10.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
+  const printed = graphql9.print(field);
+  const secondParse = graphql9.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
   const paginated = !!field.directives?.find(
     (directive) => directive.name.value === config2.paginateDirective
   );
@@ -57923,8 +57936,8 @@ function selection({
         const typeConditionName = field.typeCondition.name.value;
         const typeCondition = config2.schema.getType(typeConditionName);
         const possibleTypes = [];
-        if (!graphql11.isAbstractType(typeCondition)) {
-        } else if (graphql11.isAbstractType(parentType)) {
+        if (!graphql10.isAbstractType(typeCondition)) {
+        } else if (graphql10.isAbstractType(parentType)) {
           const possibleParentTypes = config2.schema.getPossibleTypes(parentType).map((type) => type.name);
           for (const possible of config2.schema.getPossibleTypes(typeCondition)) {
             if (possibleParentTypes.includes(possible.name)) {
@@ -57972,7 +57985,7 @@ function selection({
       } else {
         let typeRef = type.getFields()[field.name.value].type;
         fieldType = getRootType(typeRef);
-        nullable = !graphql11.isNonNullType(typeRef);
+        nullable = !graphql10.isNonNullType(typeRef);
       }
       const typeName = fieldType.toString();
       const pathSoFar = path2.concat(attributeName);
@@ -58037,7 +58050,7 @@ function selection({
           {}
         );
       }
-      if (graphql11.isInterfaceType(fieldType) || graphql11.isUnionType(fieldType)) {
+      if (graphql10.isInterfaceType(fieldType) || graphql10.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
       object.fields = {
@@ -58094,7 +58107,7 @@ function artifactGenerator(stats) {
   return async function(config2, docs) {
     const filterTypes = {};
     for (const doc of docs) {
-      graphql12.visit(doc.document, {
+      graphql11.visit(doc.document, {
         Directive(node, _, __, ___, ancestors) {
           if (node.name.value !== config2.listDirective) {
             return;
@@ -58153,7 +58166,7 @@ function artifactGenerator(stats) {
             return;
           }
           const usedVariableNames = /* @__PURE__ */ new Set();
-          let documentWithoutInternalDirectives = graphql12.visit(document, {
+          let documentWithoutInternalDirectives = graphql11.visit(document, {
             Directive(node) {
               if (config2.isInternalDirective(node)) {
                 return null;
@@ -58166,7 +58179,7 @@ function artifactGenerator(stats) {
               }
             }
           });
-          let documentWithoutExtraVariables = graphql12.visit(
+          let documentWithoutExtraVariables = graphql11.visit(
             documentWithoutInternalDirectives,
             {
               VariableDefinition(variableDefinitionNode) {
@@ -58177,13 +58190,13 @@ function artifactGenerator(stats) {
               }
             }
           );
-          let rawString = graphql12.print(documentWithoutExtraVariables);
+          let rawString = graphql11.print(documentWithoutExtraVariables);
           let docKind = doc.kind;
           const operations = document.definitions.filter(
-            ({ kind }) => kind === graphql12.Kind.OPERATION_DEFINITION
+            ({ kind }) => kind === graphql11.Kind.OPERATION_DEFINITION
           );
           const fragments = document.definitions.filter(
-            ({ kind }) => kind === graphql12.Kind.FRAGMENT_DEFINITION
+            ({ kind }) => kind === graphql11.Kind.FRAGMENT_DEFINITION
           );
           let rootType = "";
           let selectionSet;
@@ -58425,15 +58438,15 @@ async function generatePluginRuntime(config2, plugin) {
 var recast12 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/addReferencedInputTypes.ts
-var graphql15 = __toESM(require_graphql2(), 1);
+var graphql14 = __toESM(require_graphql2(), 1);
 var recast9 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/typeReference.ts
-var graphql14 = __toESM(require_graphql2(), 1);
+var graphql13 = __toESM(require_graphql2(), 1);
 var recast8 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/types.ts
-var graphql13 = __toESM(require_graphql2(), 1);
+var graphql12 = __toESM(require_graphql2(), 1);
 var recast7 = __toESM(require_main2(), 1);
 var AST7 = recast7.types.builders;
 function readonlyProperty(prop, enable = true) {
@@ -58467,7 +58480,7 @@ function scalarPropertyValue(config2, missingScalars, target) {
       return AST7.tsStringKeyword();
     }
     default: {
-      if (graphql13.isNonNullType(target) && "ofType" in target) {
+      if (graphql12.isNonNullType(target) && "ofType" in target) {
         return scalarPropertyValue(
           config2,
           missingScalars,
@@ -58488,7 +58501,7 @@ var AST8 = recast8.types.builders;
 function tsTypeReference(config2, missingScalars, definition) {
   const { type, wrappers } = unwrapType(config2, definition.type);
   let result;
-  if (graphql14.isScalarType(type)) {
+  if (graphql13.isScalarType(type)) {
     result = scalarPropertyValue(config2, missingScalars, type);
   } else {
     result = AST8.tsTypeReference(AST8.identifier(type.name));
@@ -58509,17 +58522,17 @@ function tsTypeReference(config2, missingScalars, definition) {
 var AST9 = recast9.types.builders;
 function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingScalars, rootType) {
   const { type } = unwrapType(config2, rootType);
-  if (graphql15.isScalarType(type)) {
+  if (graphql14.isScalarType(type)) {
     return;
   }
   if (visitedTypes.has(type.name)) {
     return;
   }
-  if (graphql15.isUnionType(type)) {
+  if (graphql14.isUnionType(type)) {
     throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
   }
   visitedTypes.add(type.name);
-  if (graphql15.isEnumType(type)) {
+  if (graphql14.isEnumType(type)) {
     ensureImports({
       config: config2,
       body,
@@ -58536,7 +58549,7 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
       AST9.tsPropertySignature(
         AST9.identifier(field.name),
         AST9.tsTypeAnnotation(tsTypeReference(config2, missingScalars, field)),
-        graphql15.isNullableType(field.type)
+        graphql14.isNullableType(field.type)
       )
     );
   }
@@ -58544,7 +58557,7 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
 }
 
 // src/codegen/generators/typescript/imperativeCache.ts
-var graphql16 = __toESM(require_graphql2(), 1);
+var graphql15 = __toESM(require_graphql2(), 1);
 var recast10 = __toESM(require_main2(), 1);
 var AST10 = recast10.types.builders;
 async function imperativeCacheTypef(config2, docs) {
@@ -58580,7 +58593,7 @@ function typeDefinitions(config2, body) {
   const operationTypes = [config2.schema.getMutationType(), config2.schema.getSubscriptionType()].filter(Boolean).map((type) => type?.name);
   const visitedTypes = /* @__PURE__ */ new Set();
   const types14 = Object.values(config2.schema.getTypeMap()).filter(
-    (type) => !graphql16.isAbstractType(type) && !graphql16.isScalarType(type) && !graphql16.isEnumType(type) && !graphql16.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
+    (type) => !graphql15.isAbstractType(type) && !graphql15.isScalarType(type) && !graphql15.isEnumType(type) && !graphql15.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
   );
   return AST10.tsTypeLiteral(
     types14.map((type) => {
@@ -58590,7 +58603,7 @@ function typeDefinitions(config2, body) {
       }
       let idFields = AST10.tsNeverKeyword();
       const keys = keyFieldsForType(config2.configFile, type.name);
-      if (graphql16.isObjectType(type) && keys.length > 0 && keys.every((key) => type.getFields()[key])) {
+      if (graphql15.isObjectType(type) && keys.length > 0 && keys.every((key) => type.getFields()[key])) {
         idFields = AST10.tsTypeLiteral(
           keys.map((key) => {
             const fieldType = type.getFields()[key];
@@ -58607,21 +58620,21 @@ function typeDefinitions(config2, body) {
         idFields = AST10.tsTypeLiteral([]);
       }
       let fields = AST10.tsTypeLiteral([]);
-      if (graphql16.isObjectType(type)) {
+      if (graphql15.isObjectType(type)) {
         fields = AST10.tsTypeLiteral(
           Object.entries(type.getFields()).map(
             ([key, fieldType]) => {
               const unwrapped = unwrapType(config2, fieldType.type);
               let typeOptions = AST10.tsUnionType([]);
-              if (graphql16.isScalarType(unwrapped.type)) {
+              if (graphql15.isScalarType(unwrapped.type)) {
                 typeOptions.types.push(
                   scalarPropertyValue(config2, /* @__PURE__ */ new Set(), unwrapped.type)
                 );
-              } else if (graphql16.isEnumType(unwrapped.type)) {
+              } else if (graphql15.isEnumType(unwrapped.type)) {
                 typeOptions.types.push(
                   AST10.tsTypeReference(AST10.identifier(unwrapped.type.name))
                 );
-              } else if (!graphql16.isAbstractType(unwrapped.type)) {
+              } else if (!graphql15.isAbstractType(unwrapped.type)) {
                 typeOptions.types.push(record(unwrapped.type.name));
               } else {
                 typeOptions.types.push(
@@ -58707,7 +58720,7 @@ function listDefinitions(config2, docs) {
   const lists = [];
   const visitedLists = /* @__PURE__ */ new Set();
   for (const doc of docs) {
-    graphql16.visit(doc.document, {
+    graphql15.visit(doc.document, {
       Directive(node, key, parent, path2, ancestors) {
         if (![config2.listDirective, config2.paginateDirective].includes(node.name.value)) {
           return;
@@ -58727,7 +58740,7 @@ function listDefinitions(config2, docs) {
         const targetFieldDefinition = parentType.getFields()[targetField.name.value];
         const { type: listType } = unwrapType(config2, targetFieldDefinition.type);
         const possibleTypes = [];
-        if (graphql16.isAbstractType(listType)) {
+        if (graphql15.isAbstractType(listType)) {
           possibleTypes.push(
             ...config2.schema.getPossibleTypes(listType).map((possible) => possible.name)
           );
@@ -58791,7 +58804,7 @@ function record(name2) {
 }
 
 // src/codegen/generators/typescript/inlineType.ts
-var graphql17 = __toESM(require_graphql2(), 1);
+var graphql16 = __toESM(require_graphql2(), 1);
 var recast11 = __toESM(require_main2(), 1);
 var AST11 = recast11.types.builders;
 var fragmentKey = "$fragments";
@@ -58810,9 +58823,9 @@ function inlineType({
 }) {
   const { type, wrappers } = unwrapType(config2, rootType);
   let result;
-  if (graphql17.isScalarType(type)) {
+  if (graphql16.isScalarType(type)) {
     result = scalarPropertyValue(config2, missingScalars, type);
-  } else if (graphql17.isEnumType(type)) {
+  } else if (graphql16.isEnumType(type)) {
     if (!visitedTypes.has(type.name)) {
       ensureImports({
         config: config2,
@@ -58830,11 +58843,11 @@ function inlineType({
     for (const selection2 of selections) {
       if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
         const fragmentType = config2.schema.getType(selection2.typeCondition.name.value);
-        if (!graphql17.isInterfaceType(type) && !graphql17.isUnionType(type)) {
+        if (!graphql16.isInterfaceType(type) && !graphql16.isUnionType(type)) {
           selectedFields.push(...selection2.selectionSet.selections);
           continue;
         }
-        if (!graphql17.isInterfaceType(fragmentType) && !graphql17.isUnionType(fragmentType)) {
+        if (!graphql16.isInterfaceType(fragmentType) && !graphql16.isUnionType(fragmentType)) {
           if (!inlineFragments[fragmentType.name]) {
             inlineFragments[fragmentType.name] = [];
           }
@@ -58954,7 +58967,7 @@ function inlineType({
           }
         }
       }
-      if (objectType.type === "TSTypeLiteral" && !graphql17.isInterfaceType(fragmentRootType) && !graphql17.isUnionType(fragmentRootType)) {
+      if (objectType.type === "TSTypeLiteral" && !graphql16.isInterfaceType(fragmentRootType) && !graphql16.isUnionType(fragmentRootType)) {
         const existingTypenameIndex = objectType.members.findIndex(
           (member) => member.type === "TSPropertySignature" && member.key.type === "Identifier" && member.key.name === "__typename"
         );
@@ -59021,7 +59034,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection2) {
       },
       type: schema.getType("String")
     };
-  } else if (graphql17.isNonNullType(rootType) && "getFields" in rootType.ofType) {
+  } else if (graphql16.isNonNullType(rootType) && "getFields" in rootType.ofType) {
     fields = rootType.ofType.getFields();
   } else {
     fields = rootType.getFields();
@@ -59033,7 +59046,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection2) {
       message: `Could not find type information for field ${rootType.toString()}.${selectionName} ${field}`
     });
   }
-  const fieldType = graphql17.getNamedType(field.type);
+  const fieldType = graphql16.getNamedType(field.type);
   if (!fieldType) {
     throw new HoudiniError({
       filepath,
@@ -59354,7 +59367,7 @@ async function generateFragmentTypeDefs(config2, filepath, body, selections, def
 }
 
 // src/codegen/generators/persistedQueries/index.ts
-var graphql18 = __toESM(require_graphql2(), 1);
+var graphql17 = __toESM(require_graphql2(), 1);
 async function persistOutputGenerator(config2, docs) {
   if (typeof config2.persistedQueryPath !== "string" || config2.persistedQueryPath.length === 0)
     return;
@@ -59366,8 +59379,8 @@ async function persistOutputGenerator(config2, docs) {
     if (!generateArtifact) {
       return acc;
     }
-    let rawString = graphql18.print(
-      graphql18.visit(document, {
+    let rawString = graphql17.print(
+      graphql17.visit(document, {
         Directive(node) {
           if (config2.isInternalDirective(node)) {
             return null;
@@ -59376,7 +59389,7 @@ async function persistOutputGenerator(config2, docs) {
       })
     );
     const operations = document.definitions.filter(
-      ({ kind }) => kind === graphql18.Kind.OPERATION_DEFINITION
+      ({ kind }) => kind === graphql17.Kind.OPERATION_DEFINITION
     );
     if (operations.length > 0 && operations[0].kind === "OperationDefinition") {
       acc[hashDocument(rawString)] = rawString;
@@ -59389,11 +59402,11 @@ async function persistOutputGenerator(config2, docs) {
 }
 
 // src/codegen/generators/definitions/enums.ts
-var graphql19 = __toESM(require_graphql2(), 1);
+var graphql18 = __toESM(require_graphql2(), 1);
 var recast13 = __toESM(require_main2(), 1);
 var AST13 = recast13.types.builders;
 async function definitionsGenerator(config2) {
-  const enums = graphql19.parse(graphql19.printSchema(config2.schema)).definitions.filter(
+  const enums = graphql18.parse(graphql18.printSchema(config2.schema)).definitions.filter(
     (definition) => definition.kind === "EnumTypeDefinition"
   ).filter((def) => !config2.isInternalEnum(def));
   const runtimeDefinitions = recast13.print(
@@ -59566,7 +59579,7 @@ function flattenFragments(filepath, operation, fragments) {
 }
 
 // src/codegen/transforms/schema.ts
-var graphql21 = __toESM(require_graphql2(), 1);
+var graphql20 = __toESM(require_graphql2(), 1);
 async function graphqlExtensions(config2, documents) {
   const internalSchema = `
 enum CachePolicy {
@@ -59644,19 +59657,19 @@ directive @${config2.maskEnableDirective} on FRAGMENT_SPREAD
 """
 directive @${config2.maskDisableDirective} on FRAGMENT_SPREAD
 `;
-  let currentSchema = graphql21.printSchema(config2.schema);
+  let currentSchema = graphql20.printSchema(config2.schema);
   if (!currentSchema.includes(`directive @${config2.listDirective}`)) {
     currentSchema += internalSchema;
   }
   config2.newSchema += internalSchema;
-  config2.schema = graphql21.buildSchema(currentSchema);
+  config2.schema = graphql20.buildSchema(currentSchema);
 }
 
 // src/codegen/transforms/typename.ts
-var graphql22 = __toESM(require_graphql2(), 1);
+var graphql21 = __toESM(require_graphql2(), 1);
 async function addTypename(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql22.visit(doc.document, {
+    doc.document = graphql21.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -59668,7 +59681,7 @@ async function addTypename(config2, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
-        if (graphql22.isInterfaceType(fieldType) || graphql22.isUnionType(fieldType)) {
+        if (graphql21.isInterfaceType(fieldType) || graphql21.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -59676,9 +59689,9 @@ async function addTypename(config2, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql22.Kind.FIELD,
+                  kind: graphql21.Kind.FIELD,
                   name: {
-                    kind: graphql22.Kind.NAME,
+                    kind: graphql21.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -59692,10 +59705,10 @@ async function addTypename(config2, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql23 = __toESM(require_graphql2(), 1);
+var graphql22 = __toESM(require_graphql2(), 1);
 async function addID(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql23.visit(doc.document, {
+    doc.document = graphql22.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -59708,7 +59721,7 @@ async function addID(config2, documents) {
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
         if (node.selectionSet?.selections.length > 0) {
-          if (!graphql23.isObjectType(fieldType) && !graphql23.isInterfaceType(fieldType)) {
+          if (!graphql22.isObjectType(fieldType) && !graphql22.isInterfaceType(fieldType)) {
             return;
           }
           const keyFields = config2.keyFieldsForType(fieldType.name);
@@ -59723,9 +59736,9 @@ async function addID(config2, documents) {
               continue;
             }
             selections.push({
-              kind: graphql23.Kind.FIELD,
+              kind: graphql22.Kind.FIELD,
               name: {
-                kind: graphql23.Kind.NAME,
+                kind: graphql22.Kind.NAME,
                 value: keyField
               }
             });
@@ -59744,8 +59757,8 @@ async function addID(config2, documents) {
 }
 
 // src/codegen/transforms/fragmentVariables.ts
-var graphql24 = __toESM(require_graphql2(), 1);
-var GraphqlKinds2 = graphql24.Kind;
+var graphql23 = __toESM(require_graphql2(), 1);
+var GraphqlKinds2 = graphql23.Kind;
 async function fragmentVariables(config2, documents) {
   const fragments = collectFragments(config2, documents);
   const generatedFragments = {};
@@ -59768,7 +59781,7 @@ async function fragmentVariables(config2, documents) {
     });
   }
   const doc = {
-    kind: graphql24.Kind.DOCUMENT,
+    kind: graphql23.Kind.DOCUMENT,
     definitions: Object.values(generatedFragments)
   };
   documents.push({
@@ -59804,7 +59817,7 @@ function inlineFragmentArgs({
     filepath,
     document
   ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
-  const result = graphql24.visit(document, {
+  const result = graphql23.visit(document, {
     FragmentSpread(node) {
       const { definition } = fragmentDefinitions[node.name.value];
       let { args, hash } = collectWithArguments(config2, filepath, node, scope);
@@ -59892,7 +59905,7 @@ function inlineFragmentArgs({
   });
   if (newName) {
     result.name = {
-      kind: graphql24.Kind.NAME,
+      kind: graphql23.Kind.NAME,
       value: newName
     };
   }
@@ -60004,7 +60017,7 @@ function operationScope(operation) {
 }
 
 // src/codegen/validators/typeCheck.ts
-var graphql25 = __toESM(require_graphql2(), 1);
+var graphql24 = __toESM(require_graphql2(), 1);
 async function typeCheck(config2, docs) {
   const errors = [];
   const freeLists = [];
@@ -60012,11 +60025,11 @@ async function typeCheck(config2, docs) {
   const listTypes = [];
   const fragments = {};
   for (const { document: parsed, filename } of docs) {
-    graphql25.visit(parsed, {
-      [graphql25.Kind.FRAGMENT_DEFINITION](definition) {
+    graphql24.visit(parsed, {
+      [graphql24.Kind.FRAGMENT_DEFINITION](definition) {
         fragments[definition.name.value] = definition;
       },
-      [graphql25.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
+      [graphql24.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
         if (![config2.listDirective, config2.paginateDirective].includes(directive.name.value)) {
           return;
         }
@@ -60062,14 +60075,14 @@ async function typeCheck(config2, docs) {
             );
             return;
           }
-          if (graphql25.isListType(rootType) || graphql25.isNonNullType(rootType) && graphql25.isListType(rootType.ofType)) {
+          if (graphql24.isListType(rootType) || graphql24.isNonNullType(rootType) && graphql24.isListType(rootType.ofType)) {
             needsParent = true;
             break;
           }
-          if (graphql25.isNonNullType(rootType) && "ofType" in rootType) {
+          if (graphql24.isNonNullType(rootType) && "ofType" in rootType) {
             rootType = rootType.ofType;
           }
-          if (graphql25.isScalarType(rootType)) {
+          if (graphql24.isScalarType(rootType)) {
             break;
           }
           rootType = rootType?.getFields()[parent2.name.value]?.type;
@@ -60145,9 +60158,9 @@ async function typeCheck(config2, docs) {
           );
         }
         let targetTypes = [type];
-        if (graphql25.isUnionType(type)) {
+        if (graphql24.isUnionType(type)) {
           targetTypes = config2.schema.getPossibleTypes(type);
-        } else if (graphql25.isInterfaceType(type)) {
+        } else if (graphql24.isInterfaceType(type)) {
           try {
             for (const key of config2.keyFieldsForType(type.name)) {
               if (!type.getFields()[key]) {
@@ -60185,13 +60198,13 @@ async function typeCheck(config2, docs) {
   if (errors.length > 0) {
     throw errors;
   }
-  const rules = (filepath) => [...graphql25.specifiedRules].filter(
+  const rules = (filepath) => [...graphql24.specifiedRules].filter(
     (rule) => ![
-      graphql25.NoUnusedFragmentsRule,
-      graphql25.KnownFragmentNamesRule,
-      graphql25.ExecutableDefinitionsRule,
-      graphql25.KnownDirectivesRule,
-      graphql25.KnownArgumentNamesRule
+      graphql24.NoUnusedFragmentsRule,
+      graphql24.KnownFragmentNamesRule,
+      graphql24.ExecutableDefinitionsRule,
+      graphql24.KnownDirectivesRule,
+      graphql24.KnownArgumentNamesRule
     ].includes(rule)
   ).concat(
     validateLists({
@@ -60210,7 +60223,7 @@ async function typeCheck(config2, docs) {
     noUnusedFragmentArguments(config2)
   );
   for (const { filename, document: parsed } of docs) {
-    for (const error of graphql25.validate(config2.schema, parsed, rules(filename))) {
+    for (const error of graphql24.validate(config2.schema, parsed, rules(filename))) {
       errors.push(
         new HoudiniError({
           filepath: filename,
@@ -60236,7 +60249,7 @@ var validateLists = ({
       if (!config2.isListFragment(node.name.value)) {
         if (!fragments[node.name.value]) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               "Encountered unknown fragment: " + node.name.value
             )
           );
@@ -60246,7 +60259,7 @@ var validateLists = ({
       const listName = config2.listNameFromFragment(node.name.value);
       if (!lists.includes(listName)) {
         ctx.reportError(
-          new graphql25.GraphQLError(
+          new graphql24.GraphQLError(
             "Encountered fragment referencing unknown list: " + listName
           )
         );
@@ -60271,7 +60284,7 @@ var validateLists = ({
         );
         if (parentArg) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               `@${config2.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
             )
           );
@@ -60287,7 +60300,7 @@ var validateLists = ({
         return;
       }
       ctx.reportError(
-        new graphql25.GraphQLError(
+        new graphql24.GraphQLError(
           `For this list fragment, you need to add or @${config2.listParentDirective} or @${config2.listAllListsDirective} directive to specify the behavior`
         )
       );
@@ -60297,7 +60310,7 @@ var validateLists = ({
       const directiveName = node.name.value;
       if (directiveName === "connection") {
         ctx.reportError(
-          new graphql25.GraphQLError(
+          new graphql24.GraphQLError(
             "@connection was renamed to @list. Please change your components. If you were using `cache.connection` in your components, you will need to update that to `cache.list` too."
           )
         );
@@ -60306,7 +60319,7 @@ var validateLists = ({
       if (!config2.isInternalDirective(node)) {
         if (!config2.schema.getDirective(directiveName)) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               "Encountered unknown directive: " + directiveName
             )
           );
@@ -60315,7 +60328,7 @@ var validateLists = ({
       }
       if (config2.isListOperationDirective(directiveName) && !listTypes.includes(config2.listNameFromDirective(directiveName))) {
         ctx.reportError(
-          new graphql25.GraphQLError(
+          new graphql24.GraphQLError(
             "Encountered directive referencing unknown list: " + directiveName
           )
         );
@@ -60326,7 +60339,7 @@ var validateLists = ({
 };
 function knownArguments(config2) {
   return function(ctx) {
-    const nativeValidator = graphql25.KnownArgumentNamesRule(ctx);
+    const nativeValidator = graphql24.KnownArgumentNamesRule(ctx);
     return {
       ...nativeValidator,
       Directive(directiveNode) {
@@ -60359,7 +60372,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         for (const arg of node.arguments || []) {
           if (arg.value.kind !== "ObjectValue") {
             ctx.reportError(
-              new graphql25.GraphQLError("values in @arguments must be an object")
+              new graphql24.GraphQLError("values in @arguments must be an object")
             );
             return;
           }
@@ -60369,13 +60382,13 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (!typeArg) {
             ctx.reportError(
-              new graphql25.GraphQLError("missing type field for @arguments directive")
+              new graphql24.GraphQLError("missing type field for @arguments directive")
             );
             return;
           }
-          if (typeArg.value.kind !== graphql25.Kind.STRING) {
+          if (typeArg.value.kind !== graphql24.Kind.STRING) {
             ctx.reportError(
-              new graphql25.GraphQLError("type field to @arguments must be a string")
+              new graphql24.GraphQLError("type field to @arguments must be a string")
             );
             return;
           }
@@ -60388,7 +60401,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (typeArg.value.value !== defaultValueType) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql24.GraphQLError(
                 `Invalid default value provided for ${arg.name.value}. Expected ${typeArg.value.value}, found ${defaultValueType}`
               )
             );
@@ -60406,7 +60419,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           try {
             args = fragmentArguments(config2, filepath, fragments[fragmentName]);
           } catch (e) {
-            ctx.reportError(new graphql25.GraphQLError(e.message));
+            ctx.reportError(new graphql24.GraphQLError(e.message));
             return;
           }
           fragmentArguments2[fragmentName] = args;
@@ -60429,7 +60442,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (missing.length > 0) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               "The following arguments are missing from this fragment: " + JSON.stringify(missing)
             )
           );
@@ -60440,7 +60453,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (unknown.length > 0) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               "Encountered unknown arguments: " + JSON.stringify(unknown)
             )
           );
@@ -60452,7 +60465,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             ]
           );
           for (const [applied, target] of zipped) {
-            if (applied.value.kind === graphql25.Kind.VARIABLE || applied.value.kind === graphql25.Kind.LIST || applied.value.kind === graphql25.Kind.OBJECT) {
+            if (applied.value.kind === graphql24.Kind.VARIABLE || applied.value.kind === graphql24.Kind.LIST || applied.value.kind === graphql24.Kind.OBJECT) {
               continue;
             }
             const appliedType = applied.value.kind.substring(
@@ -60461,7 +60474,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             );
             if (appliedType !== target) {
               ctx.reportError(
-                new graphql25.GraphQLError(
+                new graphql24.GraphQLError(
                   `Invalid argument type. Expected ${target}, found ${appliedType}`
                 )
               );
@@ -60482,7 +60495,7 @@ function paginateArgs(config2, filepath) {
         }
         if (alreadyPaginated) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               `@${config2.paginateDirective} can only appear in a document once.`
             )
           );
@@ -60497,7 +60510,7 @@ function paginateArgs(config2, filepath) {
         const hasRequiredArgs = definitionArgs.find((arg) => arg.required);
         if (hasRequiredArgs) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               "@paginate cannot appear on a document with required args"
             )
           );
@@ -60529,14 +60542,14 @@ function paginateArgs(config2, filepath) {
           const backwards = appliedArgs.has("last");
           if (!forward && !backwards) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql24.GraphQLError(
                 "A field with cursor-based pagination must have a first or last argument"
               )
             );
           }
           if (forward && backwards) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql24.GraphQLError(
                 `A field with cursor pagination cannot go forwards an backwards simultaneously`
               )
             );
@@ -60550,7 +60563,7 @@ function paginateArgs(config2, filepath) {
           );
           if (!appliedLimitArg) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql24.GraphQLError(
                 "A field with offset-based pagination must have a limit argument"
               )
             );
@@ -60566,20 +60579,20 @@ function noUnusedFragmentArguments(config2) {
     const args = /* @__PURE__ */ new Set();
     return {
       enter(node) {
-        if (node.kind === graphql25.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql24.Kind.FRAGMENT_DEFINITION) {
           const definitionArguments = node.directives?.filter((directive) => directive.name.value === config2.argumentsDirective).flatMap((directive) => directive.arguments);
           for (const arg of definitionArguments?.map((arg2) => arg2?.name.value) || []) {
             args.add(arg);
           }
-        } else if (node.kind === graphql25.Kind.VARIABLE) {
+        } else if (node.kind === graphql24.Kind.VARIABLE) {
           args.delete(node.name.value);
         }
       },
       leave(node) {
-        if (node.kind === graphql25.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql24.Kind.FRAGMENT_DEFINITION) {
           if (args.size > 0) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql24.GraphQLError(
                 "Encountered unused fragment arguments: " + [...args].join(",")
               )
             );
@@ -60615,7 +60628,7 @@ function nodeDirectives(config2, directives) {
         if (definition.kind === "OperationDefinition") {
           if (definition.operation !== "query") {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql24.GraphQLError(
                 `@${node.name.value} must fall on a fragment or query document`
               )
             );
@@ -60627,7 +60640,7 @@ function nodeDirectives(config2, directives) {
         }
         if (!possibleNodes.includes(definitionType)) {
           ctx.reportError(
-            new graphql25.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
+            new graphql24.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
           );
         }
       }
@@ -60646,7 +60659,7 @@ function checkMutationOperation(config2) {
         );
         if (append && prepend) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               `You can't apply both @${config2.listPrependDirective} and @${config2.listAppendDirective} at the same time`
             )
           );
@@ -60660,7 +60673,7 @@ function checkMutationOperation(config2) {
         );
         if (parentId && allLists) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               `You can't apply both @${config2.listParentDirective} and @${config2.listAllListsDirective} at the same time`
             )
           );
@@ -60682,7 +60695,7 @@ function checkMaskDirective(config2) {
         );
         if (maskEnableDirective && maskDisableDirective) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql24.GraphQLError(
               `You can't apply both @${config2.maskEnableDirective} and @${config2.maskDisableDirective} at the same time`
             )
           );
@@ -60698,7 +60711,7 @@ function getAndVerifyNodeInterface(config2) {
   if (!nodeInterface) {
     return null;
   }
-  if (!graphql25.isInterfaceType(nodeInterface)) {
+  if (!graphql24.isInterfaceType(nodeInterface)) {
     displayInvalidNodeFieldMessage(config2.logLevel);
     return null;
   }
@@ -60796,11 +60809,11 @@ async function uniqueDocumentNames(config2, docs) {
 }
 
 // src/codegen/validators/noIDAlias.ts
-var graphql26 = __toESM(require_graphql2(), 1);
+var graphql25 = __toESM(require_graphql2(), 1);
 async function noIDAlias(config2, docs) {
   const errors = [];
   for (const { filename, document } of docs) {
-    graphql26.visit(document, {
+    graphql25.visit(document, {
       Field(node, _, __, ___, ancestors) {
         const fieldType = parentTypeFromAncestors(config2.schema, filename, ancestors).name;
         if (config2.keyFieldsForType(fieldType).includes(node.alias?.value || "")) {
@@ -60998,12 +61011,12 @@ async function processJSFile(config2, contents) {
   return documents;
 }
 async function processGraphQLDocument(config2, filepath, document) {
-  const parsedDoc = graphql27.parse(document);
+  const parsedDoc = graphql26.parse(document);
   const operations = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql27.Kind.OPERATION_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql26.Kind.OPERATION_DEFINITION
   );
   const fragments = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql27.Kind.FRAGMENT_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql26.Kind.FRAGMENT_DEFINITION
   );
   if (operations.length > 1) {
     throw new HoudiniError({