houdini 0.18.2 → 0.18.3

package/build/codegen-esm/index.js

@@ -534,7 +534,7 @@ var require_kinds = __commonJS({
       value: true
     });
     exports.Kind = void 0;
-    var Kind12 = Object.freeze({
+    var Kind13 = Object.freeze({
       NAME: "Name",
       DOCUMENT: "Document",
       OPERATION_DEFINITION: "OperationDefinition",
@@ -579,7 +579,7 @@ var require_kinds = __commonJS({
       ENUM_TYPE_EXTENSION: "EnumTypeExtension",
       INPUT_OBJECT_TYPE_EXTENSION: "InputObjectTypeExtension"
     });
-    exports.Kind = Kind12;
+    exports.Kind = Kind13;
   }
 });
 
@@ -9759,7 +9759,7 @@ var require_graphql = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.graphql = graphql26;
+    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 graphql26(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(
@@ -53922,7 +53922,7 @@ var require_main2 = __commonJS({
 });
 
 // src/codegen/index.ts
-var graphql25 = __toESM(require_graphql2(), 1);
+var graphql26 = __toESM(require_graphql2(), 1);
 
 // src/lib/pipeline.ts
 async function runPipeline(config2, pipeline, target) {
@@ -56250,7 +56250,7 @@ async function find_graphql(config2, parsedScript, walker) {
 }
 
 // src/codegen/generators/artifacts/index.ts
-var graphql11 = __toESM(require_graphql2(), 1);
+var graphql12 = __toESM(require_graphql2(), 1);
 var recast5 = __toESM(require_main2(), 1);
 
 // src/codegen/utils/commonjs.ts
@@ -56854,7 +56854,7 @@ function ancestorKey(ancestors) {
 }
 
 // src/codegen/generators/artifacts/selection.ts
-var graphql10 = __toESM(require_graphql2(), 1);
+var graphql11 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.pnpm/@kitql+helper@0.5.0/node_modules/@kitql/helper/index.mjs
 var config = {
@@ -56894,10 +56894,24 @@ function logYellow(str) {
 }
 
 // src/codegen/transforms/list.ts
-var graphql8 = __toESM(require_graphql2(), 1);
+var graphql9 = __toESM(require_graphql2(), 1);
 
-// src/codegen/transforms/paginate.ts
+// src/codegen/utils/objectIdentificationSelection.ts
 var graphql7 = __toESM(require_graphql2(), 1);
+var objectIdentificationSelection = (config2, type) => {
+  return config2.keyFieldsForType(type.name).map((key) => {
+    return {
+      kind: graphql7.Kind.FIELD,
+      name: {
+        kind: graphql7.Kind.NAME,
+        value: key
+      }
+    };
+  });
+};
+
+// src/codegen/transforms/paginate.ts
+var graphql8 = __toESM(require_graphql2(), 1);
 async function paginate(config2, documents) {
   const newDocs = [];
   for (const doc of documents) {
@@ -56930,7 +56944,7 @@ async function paginate(config2, documents) {
     };
     let cursorType = "String";
     let paginationPath = [];
-    doc.document = graphql7.visit(doc.document, {
+    doc.document = graphql8.visit(doc.document, {
       Field(node, _, __, ___, ancestors) {
         const paginateDirective = node.directives?.find(
           (directive) => directive.name.value === config2.paginateDirective
@@ -56957,7 +56971,7 @@ async function paginate(config2, documents) {
         flags.offset.enabled = offsetPagination;
         flags.limit.enabled = offsetPagination;
         paginationPath = ancestors.filter(
-          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql7.Kind.FIELD
+          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql8.Kind.FIELD
         ).concat(node).map((field) => field.alias?.value || field.name.value);
         return {
           ...node,
@@ -56978,7 +56992,7 @@ async function paginate(config2, documents) {
         refetchUpdate = "prepend" /* prepend */;
       }
       let fragment = "";
-      doc.document = graphql7.visit(doc.document, {
+      doc.document = graphql8.visit(doc.document, {
         OperationDefinition(node) {
           if (node.operation !== "query") {
             throw new HoudiniError({
@@ -57032,9 +57046,9 @@ async function paginate(config2, documents) {
               directives: [
                 ...node.directives || [],
                 {
-                  kind: graphql7.Kind.DIRECTIVE,
+                  kind: graphql8.Kind.DIRECTIVE,
                   name: {
-                    kind: graphql7.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: config2.argumentsDirective
                   }
                 }
@@ -57097,16 +57111,16 @@ async function paginate(config2, documents) {
       const paginationArgs = Object.entries(flags).filter(([_, { enabled }]) => enabled).map(([key, value]) => ({ name: key, ...value }));
       const fragmentSpreadSelection = [
         {
-          kind: graphql7.Kind.FRAGMENT_SPREAD,
+          kind: graphql8.Kind.FRAGMENT_SPREAD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: fragmentName
           },
           directives: [
             {
-              kind: graphql7.Kind.DIRECTIVE,
+              kind: graphql8.Kind.DIRECTIVE,
               name: {
-                kind: graphql7.Kind.NAME,
+                kind: graphql8.Kind.NAME,
                 value: config2.withDirective
               },
               ["arguments"]: paginationArgs.map(
@@ -57134,29 +57148,29 @@ async function paginate(config2, documents) {
       });
       const typeConfig = config2.typeConfig?.[fragment];
       const queryDoc = {
-        kind: graphql7.Kind.DOCUMENT,
+        kind: graphql8.Kind.DOCUMENT,
         definitions: [
           {
-            kind: graphql7.Kind.OPERATION_DEFINITION,
+            kind: graphql8.Kind.OPERATION_DEFINITION,
             name: {
-              kind: graphql7.Kind.NAME,
+              kind: graphql8.Kind.NAME,
               value: refetchQueryName
             },
             operation: "query",
             variableDefinitions: paginationArgs.map(
               (arg) => ({
-                kind: graphql7.Kind.VARIABLE_DEFINITION,
+                kind: graphql8.Kind.VARIABLE_DEFINITION,
                 type: {
-                  kind: graphql7.Kind.NAMED_TYPE,
+                  kind: graphql8.Kind.NAMED_TYPE,
                   name: {
-                    kind: graphql7.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: arg.type
                   }
                 },
                 variable: {
-                  kind: graphql7.Kind.VARIABLE,
+                  kind: graphql8.Kind.VARIABLE,
                   name: {
-                    kind: graphql7.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: arg.name
                   }
                 },
@@ -57168,12 +57182,12 @@ async function paginate(config2, documents) {
             ).concat(
               !nodeQuery ? [] : keys.map(
                 (key) => ({
-                  kind: graphql7.Kind.VARIABLE_DEFINITION,
+                  kind: graphql8.Kind.VARIABLE_DEFINITION,
                   type: key.type,
                   variable: {
-                    kind: graphql7.Kind.VARIABLE,
+                    kind: graphql8.Kind.VARIABLE,
                     name: {
-                      kind: graphql7.Kind.NAME,
+                      kind: graphql8.Kind.NAME,
                       value: key.name
                     }
                   }
@@ -57181,42 +57195,42 @@ async function paginate(config2, documents) {
               )
             ),
             selectionSet: {
-              kind: graphql7.Kind.SELECTION_SET,
+              kind: graphql8.Kind.SELECTION_SET,
               selections: !nodeQuery ? fragmentSpreadSelection : [
                 {
-                  kind: graphql7.Kind.FIELD,
+                  kind: graphql8.Kind.FIELD,
                   name: {
-                    kind: graphql7.Kind.NAME,
+                    kind: graphql8.Kind.NAME,
                     value: typeConfig?.resolve?.queryField || "node"
                   },
                   ["arguments"]: keys.map((key) => ({
-                    kind: graphql7.Kind.ARGUMENT,
+                    kind: graphql8.Kind.ARGUMENT,
                     name: {
-                      kind: graphql7.Kind.NAME,
+                      kind: graphql8.Kind.NAME,
                       value: key.name
                     },
                     value: {
-                      kind: graphql7.Kind.VARIABLE,
+                      kind: graphql8.Kind.VARIABLE,
                       name: {
-                        kind: graphql7.Kind.NAME,
+                        kind: graphql8.Kind.NAME,
                         value: key.name
                       }
                     }
                   })),
                   selectionSet: {
-                    kind: graphql7.Kind.SELECTION_SET,
+                    kind: graphql8.Kind.SELECTION_SET,
                     selections: [
                       {
-                        kind: graphql7.Kind.FIELD,
+                        kind: graphql8.Kind.FIELD,
                         name: {
-                          kind: graphql7.Kind.NAME,
+                          kind: graphql8.Kind.NAME,
                           value: "__typename"
                         }
                       },
                       ...(typeConfig?.keys || ["id"]).map((key) => ({
-                        kind: graphql7.Kind.FIELD,
+                        kind: graphql8.Kind.FIELD,
                         name: {
-                          kind: graphql7.Kind.NAME,
+                          kind: graphql8.Kind.NAME,
                           value: key
                         }
                       })),
@@ -57278,15 +57292,15 @@ function replaceArgumentsWithVariables(args, flags) {
 }
 function variableAsArgument(name2, variable) {
   return {
-    kind: graphql7.Kind.ARGUMENT,
+    kind: graphql8.Kind.ARGUMENT,
     name: {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: name2
     },
     value: {
-      kind: graphql7.Kind.VARIABLE,
+      kind: graphql8.Kind.VARIABLE,
       name: {
-        kind: graphql7.Kind.NAME,
+        kind: graphql8.Kind.NAME,
         value: variable ?? name2
       }
     }
@@ -57294,18 +57308,18 @@ function variableAsArgument(name2, variable) {
 }
 function staticVariableDefinition(name2, type, defaultValue, variableName) {
   return {
-    kind: graphql7.Kind.VARIABLE_DEFINITION,
+    kind: graphql8.Kind.VARIABLE_DEFINITION,
     type: {
-      kind: graphql7.Kind.NAMED_TYPE,
+      kind: graphql8.Kind.NAMED_TYPE,
       name: {
-        kind: graphql7.Kind.NAME,
+        kind: graphql8.Kind.NAME,
         value: type
       }
     },
     variable: {
-      kind: graphql7.Kind.VARIABLE,
+      kind: graphql8.Kind.VARIABLE,
       name: {
-        kind: graphql7.Kind.NAME,
+        kind: graphql8.Kind.NAME,
         value: variableName ?? name2
       }
     },
@@ -57317,9 +57331,9 @@ function staticVariableDefinition(name2, type, defaultValue, variableName) {
 }
 function argumentNode(name2, value) {
   return {
-    kind: graphql7.Kind.ARGUMENT,
+    kind: graphql8.Kind.ARGUMENT,
     name: {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: name2
     },
     value: objectNode(value)
@@ -57327,16 +57341,16 @@ function argumentNode(name2, value) {
 }
 function objectNode([type, defaultValue]) {
   const node = {
-    kind: graphql7.Kind.OBJECT,
+    kind: graphql8.Kind.OBJECT,
     fields: [
       {
-        kind: graphql7.Kind.OBJECT_FIELD,
+        kind: graphql8.Kind.OBJECT_FIELD,
         name: {
-          kind: graphql7.Kind.NAME,
+          kind: graphql8.Kind.NAME,
           value: "type"
         },
         value: {
-          kind: graphql7.Kind.STRING,
+          kind: graphql8.Kind.STRING,
           value: type
         }
       }
@@ -57344,8 +57358,8 @@ function objectNode([type, defaultValue]) {
   };
   if (defaultValue) {
     node.fields.push({
-      kind: graphql7.Kind.OBJECT_FIELD,
-      name: { kind: graphql7.Kind.NAME, value: "default" },
+      kind: graphql8.Kind.OBJECT_FIELD,
+      name: { kind: graphql8.Kind.NAME, value: "default" },
       value: {
         kind: typeof defaultValue === "number" ? "IntValue" : "StringValue",
         value: defaultValue.toString()
@@ -57356,34 +57370,34 @@ function objectNode([type, defaultValue]) {
 }
 var pageInfoSelection = [
   {
-    kind: graphql7.Kind.FIELD,
+    kind: graphql8.Kind.FIELD,
     name: {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: "edges"
     },
     selectionSet: {
-      kind: graphql7.Kind.SELECTION_SET,
+      kind: graphql8.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "cursor"
           }
         },
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "node"
           },
           selectionSet: {
-            kind: graphql7.Kind.SELECTION_SET,
+            kind: graphql8.Kind.SELECTION_SET,
             selections: [
               {
-                kind: graphql7.Kind.FIELD,
+                kind: graphql8.Kind.FIELD,
                 name: {
-                  kind: graphql7.Kind.NAME,
+                  kind: graphql8.Kind.NAME,
                   value: "__typename"
                 }
               }
@@ -57394,39 +57408,39 @@ var pageInfoSelection = [
     }
   },
   {
-    kind: graphql7.Kind.FIELD,
+    kind: graphql8.Kind.FIELD,
     name: {
-      kind: graphql7.Kind.NAME,
+      kind: graphql8.Kind.NAME,
       value: "pageInfo"
     },
     selectionSet: {
-      kind: graphql7.Kind.SELECTION_SET,
+      kind: graphql8.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "hasPreviousPage"
           }
         },
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "hasNextPage"
           }
         },
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "startCursor"
           }
         },
         {
-          kind: graphql7.Kind.FIELD,
+          kind: graphql8.Kind.FIELD,
           name: {
-            kind: graphql7.Kind.NAME,
+            kind: graphql8.Kind.NAME,
             value: "endCursor"
           }
         }
@@ -57440,15 +57454,15 @@ async function addListFragments(config2, documents) {
   const lists = {};
   const errors = [];
   for (const doc of documents) {
-    doc.document = graphql8.visit(doc.document, {
+    doc.document = graphql9.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 graphql8.GraphQLError(
+            ...new graphql9.GraphQLError(
               "",
               node,
-              new graphql8.Source(""),
+              new graphql9.Source(""),
               node.loc ? [node.loc.start, node.loc.end] : null,
               path2
             ),
@@ -57500,7 +57514,7 @@ async function addListFragments(config2, documents) {
                 {
                   kind: "Argument",
                   name: {
-                    kind: graphql8.Kind.NAME,
+                    kind: graphql9.Kind.NAME,
                     value: "connection"
                   },
                   value: {
@@ -57547,10 +57561,13 @@ async function addListFragments(config2, documents) {
   if (errors.length > 0) {
     throw errors;
   }
-  const listTargets = [
+  const validDeletes = [
     ...new Set(
       Object.values(lists).map(({ type }) => {
-        if (!(type instanceof graphql8.GraphQLObjectType)) {
+        if (!(type instanceof graphql9.GraphQLObjectType)) {
+          return "";
+        }
+        if (config2.keyFieldsForType(type.name).length !== 1) {
           return "";
         }
         return type.name;
@@ -57561,7 +57578,7 @@ async function addListFragments(config2, documents) {
     return;
   }
   const generatedDoc = {
-    kind: graphql8.Kind.DOCUMENT,
+    kind: graphql9.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
       ([name2, { selection: selection2, type }]) => {
         const schemaType = config2.schema.getType(type.name);
@@ -57569,35 +57586,29 @@ async function addListFragments(config2, documents) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
-          kind: graphql8.Kind.SELECTION_SET,
+          kind: graphql9.Kind.SELECTION_SET,
           selections: [...selection2.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
-          (field) => field.kind === "Field" && field.name.value === "id"
+          (field) => field.kind === "Field" && config2.keyFieldsForType(type.name).includes(field.name.value)
         )) {
           fragmentSelection.selections = [
             ...fragmentSelection.selections,
-            {
-              kind: graphql8.Kind.FIELD,
-              name: {
-                kind: graphql8.Kind.NAME,
-                value: "id"
-              }
-            }
+            ...objectIdentificationSelection(config2, type)
           ];
         }
         return [
           {
             name: {
               value: config2.listInsertFragment(name2),
-              kind: graphql8.Kind.NAME
+              kind: graphql9.Kind.NAME
             },
-            kind: graphql8.Kind.FRAGMENT_DEFINITION,
+            kind: graphql9.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql8.Kind.NAMED_TYPE,
+              kind: graphql9.Kind.NAMED_TYPE,
               name: {
-                kind: graphql8.Kind.NAME,
+                kind: graphql9.Kind.NAME,
                 value: type.name
               }
             }
@@ -57605,52 +57616,32 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listToggleFragment(name2),
-              kind: graphql8.Kind.NAME
-            },
-            kind: graphql8.Kind.FRAGMENT_DEFINITION,
-            selectionSet: {
-              ...fragmentSelection,
-              selections: [
-                ...fragmentSelection.selections,
-                {
-                  kind: graphql8.Kind.FIELD,
-                  name: {
-                    kind: graphql8.Kind.NAME,
-                    value: "id"
-                  }
-                }
-              ]
+              kind: graphql9.Kind.NAME
             },
+            kind: graphql9.Kind.FRAGMENT_DEFINITION,
+            selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql8.Kind.NAMED_TYPE,
+              kind: graphql9.Kind.NAMED_TYPE,
               name: {
-                kind: graphql8.Kind.NAME,
+                kind: graphql9.Kind.NAME,
                 value: type.name
               }
             }
           },
           {
-            kind: graphql8.Kind.FRAGMENT_DEFINITION,
+            kind: graphql9.Kind.FRAGMENT_DEFINITION,
             name: {
               value: config2.listRemoveFragment(name2),
-              kind: graphql8.Kind.NAME
+              kind: graphql9.Kind.NAME
             },
             selectionSet: {
-              kind: graphql8.Kind.SELECTION_SET,
-              selections: [
-                {
-                  kind: graphql8.Kind.FIELD,
-                  name: {
-                    kind: graphql8.Kind.NAME,
-                    value: "id"
-                  }
-                }
-              ]
+              kind: graphql9.Kind.SELECTION_SET,
+              selections: [...objectIdentificationSelection(config2, type)]
             },
             typeCondition: {
-              kind: graphql8.Kind.NAMED_TYPE,
+              kind: graphql9.Kind.NAMED_TYPE,
               name: {
-                kind: graphql8.Kind.NAME,
+                kind: graphql9.Kind.NAME,
                 value: type.name
               }
             }
@@ -57658,15 +57649,15 @@ async function addListFragments(config2, documents) {
         ];
       }
     ).concat(
-      ...listTargets.map((typeName) => ({
-        kind: graphql8.Kind.DIRECTIVE_DEFINITION,
+      ...validDeletes.map((typeName) => ({
+        kind: graphql9.Kind.DIRECTIVE_DEFINITION,
         name: {
-          kind: graphql8.Kind.NAME,
+          kind: graphql9.Kind.NAME,
           value: config2.listDeleteDirective(typeName)
         },
         locations: [
           {
-            kind: graphql8.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: "FIELD"
           }
         ],
@@ -57674,8 +57665,8 @@ async function addListFragments(config2, documents) {
       }))
     )
   };
-  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");
+  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");
   documents.push({
     name: "generated::lists",
     kind: "HoudiniFragment" /* Fragment */,
@@ -57760,11 +57751,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 graphql9 = __toESM(require_graphql2(), 1);
+var graphql10 = __toESM(require_graphql2(), 1);
 function fieldKey(config2, field) {
   const attributeName = field.alias?.value || field.name.value;
-  const printed = graphql9.print(field);
-  const secondParse = graphql9.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
+  const printed = graphql10.print(field);
+  const secondParse = graphql10.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
   const paginated = !!field.directives?.find(
     (directive) => directive.name.value === config2.paginateDirective
   );
@@ -57857,8 +57848,8 @@ function selection({
         const typeConditionName = field.typeCondition.name.value;
         const typeCondition = config2.schema.getType(typeConditionName);
         const possibleTypes = [];
-        if (!graphql10.isAbstractType(typeCondition)) {
-        } else if (graphql10.isAbstractType(parentType)) {
+        if (!graphql11.isAbstractType(typeCondition)) {
+        } else if (graphql11.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)) {
@@ -57906,7 +57897,7 @@ function selection({
       } else {
         let typeRef = type.getFields()[field.name.value].type;
         fieldType = getRootType(typeRef);
-        nullable = !graphql10.isNonNullType(typeRef);
+        nullable = !graphql11.isNonNullType(typeRef);
       }
       const typeName = fieldType.toString();
       const pathSoFar = path2.concat(attributeName);
@@ -57971,7 +57962,7 @@ function selection({
           {}
         );
       }
-      if (graphql10.isInterfaceType(fieldType) || graphql10.isUnionType(fieldType)) {
+      if (graphql11.isInterfaceType(fieldType) || graphql11.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
       object.fields = {
@@ -58028,7 +58019,7 @@ function artifactGenerator(stats) {
   return async function(config2, docs) {
     const filterTypes = {};
     for (const doc of docs) {
-      graphql11.visit(doc.document, {
+      graphql12.visit(doc.document, {
         Directive(node, _, __, ___, ancestors) {
           if (node.name.value !== config2.listDirective) {
             return;
@@ -58087,7 +58078,7 @@ function artifactGenerator(stats) {
             return;
           }
           const usedVariableNames = /* @__PURE__ */ new Set();
-          let documentWithoutInternalDirectives = graphql11.visit(document, {
+          let documentWithoutInternalDirectives = graphql12.visit(document, {
             Directive(node) {
               if (config2.isInternalDirective(node)) {
                 return null;
@@ -58100,7 +58091,7 @@ function artifactGenerator(stats) {
               }
             }
           });
-          let documentWithoutExtraVariables = graphql11.visit(
+          let documentWithoutExtraVariables = graphql12.visit(
             documentWithoutInternalDirectives,
             {
               VariableDefinition(variableDefinitionNode) {
@@ -58111,13 +58102,13 @@ function artifactGenerator(stats) {
               }
             }
           );
-          let rawString = graphql11.print(documentWithoutExtraVariables);
+          let rawString = graphql12.print(documentWithoutExtraVariables);
           let docKind = doc.kind;
           const operations = document.definitions.filter(
-            ({ kind }) => kind === graphql11.Kind.OPERATION_DEFINITION
+            ({ kind }) => kind === graphql12.Kind.OPERATION_DEFINITION
           );
           const fragments = document.definitions.filter(
-            ({ kind }) => kind === graphql11.Kind.FRAGMENT_DEFINITION
+            ({ kind }) => kind === graphql12.Kind.FRAGMENT_DEFINITION
           );
           let rootType = "";
           let selectionSet;
@@ -58304,15 +58295,15 @@ async function generatePluginRuntime(config2, plugin) {
 var recast10 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/addReferencedInputTypes.ts
-var graphql14 = __toESM(require_graphql2(), 1);
+var graphql15 = __toESM(require_graphql2(), 1);
 var recast8 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/typeReference.ts
-var graphql13 = __toESM(require_graphql2(), 1);
+var graphql14 = __toESM(require_graphql2(), 1);
 var recast7 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/types.ts
-var graphql12 = __toESM(require_graphql2(), 1);
+var graphql13 = __toESM(require_graphql2(), 1);
 var recast6 = __toESM(require_main2(), 1);
 var AST6 = recast6.types.builders;
 function readonlyProperty(prop, enable = true) {
@@ -58346,7 +58337,7 @@ function scalarPropertyValue(config2, missingScalars, target) {
       return AST6.tsStringKeyword();
     }
     default: {
-      if (graphql12.isNonNullType(target) && "ofType" in target) {
+      if (graphql13.isNonNullType(target) && "ofType" in target) {
         return scalarPropertyValue(
           config2,
           missingScalars,
@@ -58367,7 +58358,7 @@ var AST7 = recast7.types.builders;
 function tsTypeReference(config2, missingScalars, definition) {
   const { type, wrappers } = unwrapType(config2, definition.type);
   let result;
-  if (graphql13.isScalarType(type)) {
+  if (graphql14.isScalarType(type)) {
     result = scalarPropertyValue(config2, missingScalars, type);
   } else {
     result = AST7.tsTypeReference(AST7.identifier(type.name));
@@ -58388,17 +58379,17 @@ function tsTypeReference(config2, missingScalars, definition) {
 var AST8 = recast8.types.builders;
 function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingScalars, rootType) {
   const { type } = unwrapType(config2, rootType);
-  if (graphql14.isScalarType(type)) {
+  if (graphql15.isScalarType(type)) {
     return;
   }
   if (visitedTypes.has(type.name)) {
     return;
   }
-  if (graphql14.isUnionType(type)) {
+  if (graphql15.isUnionType(type)) {
     throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
   }
   visitedTypes.add(type.name);
-  if (graphql14.isEnumType(type)) {
+  if (graphql15.isEnumType(type)) {
     ensureImports({
       config: config2,
       body,
@@ -58415,7 +58406,7 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
       AST8.tsPropertySignature(
         AST8.identifier(field.name),
         AST8.tsTypeAnnotation(tsTypeReference(config2, missingScalars, field)),
-        graphql14.isNullableType(field.type)
+        graphql15.isNullableType(field.type)
       )
     );
   }
@@ -58423,7 +58414,7 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
 }
 
 // src/codegen/generators/typescript/inlineType.ts
-var graphql15 = __toESM(require_graphql2(), 1);
+var graphql16 = __toESM(require_graphql2(), 1);
 var recast9 = __toESM(require_main2(), 1);
 var AST9 = recast9.types.builders;
 var fragmentKey = "$fragments";
@@ -58442,9 +58433,9 @@ function inlineType({
 }) {
   const { type, wrappers } = unwrapType(config2, rootType);
   let result;
-  if (graphql15.isScalarType(type)) {
+  if (graphql16.isScalarType(type)) {
     result = scalarPropertyValue(config2, missingScalars, type);
-  } else if (graphql15.isEnumType(type)) {
+  } else if (graphql16.isEnumType(type)) {
     if (!visitedTypes.has(type.name)) {
       ensureImports({
         config: config2,
@@ -58462,11 +58453,11 @@ function inlineType({
     for (const selection2 of selections) {
       if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
         const fragmentType = config2.schema.getType(selection2.typeCondition.name.value);
-        if (!graphql15.isInterfaceType(type) && !graphql15.isUnionType(type)) {
+        if (!graphql16.isInterfaceType(type) && !graphql16.isUnionType(type)) {
           selectedFields.push(...selection2.selectionSet.selections);
           continue;
         }
-        if (!graphql15.isInterfaceType(fragmentType) && !graphql15.isUnionType(fragmentType)) {
+        if (!graphql16.isInterfaceType(fragmentType) && !graphql16.isUnionType(fragmentType)) {
           if (!inlineFragments[fragmentType.name]) {
             inlineFragments[fragmentType.name] = [];
           }
@@ -58586,7 +58577,7 @@ function inlineType({
           }
         }
       }
-      if (objectType.type === "TSTypeLiteral" && !graphql15.isInterfaceType(fragmentRootType) && !graphql15.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"
         );
@@ -58653,7 +58644,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection2) {
       },
       type: schema.getType("String")
     };
-  } else if (graphql15.isNonNullType(rootType) && "getFields" in rootType.ofType) {
+  } else if (graphql16.isNonNullType(rootType) && "getFields" in rootType.ofType) {
     fields = rootType.ofType.getFields();
   } else {
     fields = rootType.getFields();
@@ -58665,7 +58656,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection2) {
       message: `Could not find type information for field ${rootType.toString()}.${selectionName} ${field}`
     });
   }
-  const fieldType = graphql15.getNamedType(field.type);
+  const fieldType = graphql16.getNamedType(field.type);
   if (!fieldType) {
     throw new HoudiniError({
       filepath,
@@ -58985,7 +58976,7 @@ async function generateFragmentTypeDefs(config2, filepath, body, selections, def
 }
 
 // src/codegen/generators/persistedQueries/index.ts
-var graphql16 = __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;
@@ -58997,8 +58988,8 @@ async function persistOutputGenerator(config2, docs) {
     if (!generateArtifact) {
       return acc;
     }
-    let rawString = graphql16.print(
-      graphql16.visit(document, {
+    let rawString = graphql17.print(
+      graphql17.visit(document, {
         Directive(node) {
           if (config2.isInternalDirective(node)) {
             return null;
@@ -59007,7 +58998,7 @@ async function persistOutputGenerator(config2, docs) {
       })
     );
     const operations = document.definitions.filter(
-      ({ kind }) => kind === graphql16.Kind.OPERATION_DEFINITION
+      ({ kind }) => kind === graphql17.Kind.OPERATION_DEFINITION
     );
     if (operations.length > 0 && operations[0].kind === "OperationDefinition") {
       acc[hashDocument(rawString)] = rawString;
@@ -59020,11 +59011,11 @@ async function persistOutputGenerator(config2, docs) {
 }
 
 // src/codegen/generators/definitions/enums.ts
-var graphql17 = __toESM(require_graphql2(), 1);
+var graphql18 = __toESM(require_graphql2(), 1);
 var recast11 = __toESM(require_main2(), 1);
 var AST11 = recast11.types.builders;
 async function definitionsGenerator(config2) {
-  const enums = graphql17.parse(graphql17.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 = recast11.print(
@@ -59197,7 +59188,7 @@ function flattenFragments(filepath, operation, fragments) {
 }
 
 // src/codegen/transforms/schema.ts
-var graphql19 = __toESM(require_graphql2(), 1);
+var graphql20 = __toESM(require_graphql2(), 1);
 async function graphqlExtensions(config2, documents) {
   const internalSchema = `
 enum CachePolicy {
@@ -59275,19 +59266,19 @@ directive @${config2.maskEnableDirective} on FRAGMENT_SPREAD
 """
 directive @${config2.maskDisableDirective} on FRAGMENT_SPREAD
 `;
-  let currentSchema = graphql19.printSchema(config2.schema);
+  let currentSchema = graphql20.printSchema(config2.schema);
   if (!currentSchema.includes(`directive @${config2.listDirective}`)) {
     currentSchema += internalSchema;
   }
   config2.newSchema += internalSchema;
-  config2.schema = graphql19.buildSchema(currentSchema);
+  config2.schema = graphql20.buildSchema(currentSchema);
 }
 
 // src/codegen/transforms/typename.ts
-var graphql20 = __toESM(require_graphql2(), 1);
+var graphql21 = __toESM(require_graphql2(), 1);
 async function addTypename(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql20.visit(doc.document, {
+    doc.document = graphql21.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -59299,7 +59290,7 @@ async function addTypename(config2, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
-        if (graphql20.isInterfaceType(fieldType) || graphql20.isUnionType(fieldType)) {
+        if (graphql21.isInterfaceType(fieldType) || graphql21.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -59307,9 +59298,9 @@ async function addTypename(config2, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql20.Kind.FIELD,
+                  kind: graphql21.Kind.FIELD,
                   name: {
-                    kind: graphql20.Kind.NAME,
+                    kind: graphql21.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -59323,10 +59314,10 @@ async function addTypename(config2, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql21 = __toESM(require_graphql2(), 1);
+var graphql22 = __toESM(require_graphql2(), 1);
 async function addID(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql21.visit(doc.document, {
+    doc.document = graphql22.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -59339,7 +59330,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 (!graphql21.isObjectType(fieldType) && !graphql21.isInterfaceType(fieldType)) {
+          if (!graphql22.isObjectType(fieldType) && !graphql22.isInterfaceType(fieldType)) {
             return;
           }
           const keyFields = config2.keyFieldsForType(fieldType.name);
@@ -59354,9 +59345,9 @@ async function addID(config2, documents) {
               continue;
             }
             selections.push({
-              kind: graphql21.Kind.FIELD,
+              kind: graphql22.Kind.FIELD,
               name: {
-                kind: graphql21.Kind.NAME,
+                kind: graphql22.Kind.NAME,
                 value: keyField
               }
             });
@@ -59375,8 +59366,8 @@ async function addID(config2, documents) {
 }
 
 // src/codegen/transforms/fragmentVariables.ts
-var graphql22 = __toESM(require_graphql2(), 1);
-var GraphqlKinds2 = graphql22.Kind;
+var graphql23 = __toESM(require_graphql2(), 1);
+var GraphqlKinds2 = graphql23.Kind;
 async function fragmentVariables(config2, documents) {
   const fragments = collectFragments(config2, documents);
   const generatedFragments = {};
@@ -59399,7 +59390,7 @@ async function fragmentVariables(config2, documents) {
     });
   }
   const doc = {
-    kind: graphql22.Kind.DOCUMENT,
+    kind: graphql23.Kind.DOCUMENT,
     definitions: Object.values(generatedFragments)
   };
   documents.push({
@@ -59435,7 +59426,7 @@ function inlineFragmentArgs({
     filepath,
     document
   ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
-  const result = graphql22.visit(document, {
+  const result = graphql23.visit(document, {
     FragmentSpread(node) {
       const { definition } = fragmentDefinitions[node.name.value];
       let { args, hash } = collectWithArguments(config2, filepath, node, scope);
@@ -59523,7 +59514,7 @@ function inlineFragmentArgs({
   });
   if (newName) {
     result.name = {
-      kind: graphql22.Kind.NAME,
+      kind: graphql23.Kind.NAME,
       value: newName
     };
   }
@@ -59635,7 +59626,7 @@ function operationScope(operation) {
 }
 
 // src/codegen/validators/typeCheck.ts
-var graphql23 = __toESM(require_graphql2(), 1);
+var graphql24 = __toESM(require_graphql2(), 1);
 async function typeCheck(config2, docs) {
   const errors = [];
   const freeLists = [];
@@ -59643,11 +59634,11 @@ async function typeCheck(config2, docs) {
   const listTypes = [];
   const fragments = {};
   for (const { document: parsed, filename } of docs) {
-    graphql23.visit(parsed, {
-      [graphql23.Kind.FRAGMENT_DEFINITION](definition) {
+    graphql24.visit(parsed, {
+      [graphql24.Kind.FRAGMENT_DEFINITION](definition) {
         fragments[definition.name.value] = definition;
       },
-      [graphql23.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
+      [graphql24.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
         if (![config2.listDirective, config2.paginateDirective].includes(directive.name.value)) {
           return;
         }
@@ -59693,14 +59684,14 @@ async function typeCheck(config2, docs) {
             );
             return;
           }
-          if (graphql23.isListType(rootType) || graphql23.isNonNullType(rootType) && graphql23.isListType(rootType.ofType)) {
+          if (graphql24.isListType(rootType) || graphql24.isNonNullType(rootType) && graphql24.isListType(rootType.ofType)) {
             needsParent = true;
             break;
           }
-          if (graphql23.isNonNullType(rootType) && "ofType" in rootType) {
+          if (graphql24.isNonNullType(rootType) && "ofType" in rootType) {
             rootType = rootType.ofType;
           }
-          if (graphql23.isScalarType(rootType)) {
+          if (graphql24.isScalarType(rootType)) {
             break;
           }
           rootType = rootType?.getFields()[parent2.name.value]?.type;
@@ -59756,7 +59747,7 @@ async function typeCheck(config2, docs) {
         );
         const targetField = ancestors[ancestors.length - 1];
         const targetFieldDefinition = pType.getFields()[targetField.name.value];
-        const { type, error } = connectionSelection(
+        const { type, error: errorConnectionSelection } = connectionSelection(
           config2,
           targetFieldDefinition,
           parentTypeFromAncestors(
@@ -59766,10 +59757,19 @@ async function typeCheck(config2, docs) {
           ),
           targetField.selectionSet
         );
+        if (errorConnectionSelection && directive.name.value === config2.paginateDirective) {
+          errors.push(
+            new HoudiniError({
+              filepath: filename,
+              message: errorConnectionSelection,
+              description: errorConnectionSelection
+            })
+          );
+        }
         let targetTypes = [type];
-        if (graphql23.isUnionType(type)) {
+        if (graphql24.isUnionType(type)) {
           targetTypes = config2.schema.getPossibleTypes(type);
-        } else if (graphql23.isInterfaceType(type)) {
+        } else if (graphql24.isInterfaceType(type)) {
           try {
             for (const key of config2.keyFieldsForType(type.name)) {
               if (!type.getFields()[key]) {
@@ -59783,23 +59783,16 @@ async function typeCheck(config2, docs) {
         for (const targetType of targetTypes) {
           const missingIDFields = config2.keyFieldsForType(targetType.name).filter((fieldName) => !targetType.getFields()[fieldName]);
           if (missingIDFields.length > 0) {
-            if (error) {
-              errors.push(
-                new HoudiniError({
-                  filepath: filename,
-                  message: error
-                })
-              );
-            } else {
-              errors.push(
-                new HoudiniError({
-                  filepath: filename,
-                  message: `@${config2.listDirective} can only be applied to types with the necessary id fields: ${missingIDFields.join(
-                    ", "
-                  )}.`
-                })
-              );
-            }
+            const message = `@${config2.listDirective} on ${logGreen(
+              targetType.name
+            )} as a configuration issue. Object identification missing: ${missingIDFields.map((c) => `"${logYellow(c)}"`).join(", ")}. Check 'Custom IDs' if needed.`;
+            errors.push(
+              new HoudiniError({
+                filepath: filename,
+                message,
+                description: message
+              })
+            );
             return;
           }
         }
@@ -59814,13 +59807,13 @@ async function typeCheck(config2, docs) {
   if (errors.length > 0) {
     throw errors;
   }
-  const rules = (filepath) => [...graphql23.specifiedRules].filter(
+  const rules = (filepath) => [...graphql24.specifiedRules].filter(
     (rule) => ![
-      graphql23.NoUnusedFragmentsRule,
-      graphql23.KnownFragmentNamesRule,
-      graphql23.ExecutableDefinitionsRule,
-      graphql23.KnownDirectivesRule,
-      graphql23.KnownArgumentNamesRule
+      graphql24.NoUnusedFragmentsRule,
+      graphql24.KnownFragmentNamesRule,
+      graphql24.ExecutableDefinitionsRule,
+      graphql24.KnownDirectivesRule,
+      graphql24.KnownArgumentNamesRule
     ].includes(rule)
   ).concat(
     validateLists({
@@ -59839,7 +59832,7 @@ async function typeCheck(config2, docs) {
     noUnusedFragmentArguments(config2)
   );
   for (const { filename, document: parsed } of docs) {
-    for (const error of graphql23.validate(config2.schema, parsed, rules(filename))) {
+    for (const error of graphql24.validate(config2.schema, parsed, rules(filename))) {
       errors.push(
         new HoudiniError({
           filepath: filename,
@@ -59865,7 +59858,7 @@ var validateLists = ({
       if (!config2.isListFragment(node.name.value)) {
         if (!fragments[node.name.value]) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               "Encountered unknown fragment: " + node.name.value
             )
           );
@@ -59875,7 +59868,7 @@ var validateLists = ({
       const listName = config2.listNameFromFragment(node.name.value);
       if (!lists.includes(listName)) {
         ctx.reportError(
-          new graphql23.GraphQLError(
+          new graphql24.GraphQLError(
             "Encountered fragment referencing unknown list: " + listName
           )
         );
@@ -59900,7 +59893,7 @@ var validateLists = ({
         );
         if (parentArg) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               `@${config2.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
             )
           );
@@ -59916,7 +59909,7 @@ var validateLists = ({
         return;
       }
       ctx.reportError(
-        new graphql23.GraphQLError(
+        new graphql24.GraphQLError(
           `For this list fragment, you need to add or @${config2.listParentDirective} or @${config2.listAllListsDirective} directive to specify the behavior`
         )
       );
@@ -59926,7 +59919,7 @@ var validateLists = ({
       const directiveName = node.name.value;
       if (directiveName === "connection") {
         ctx.reportError(
-          new graphql23.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."
           )
         );
@@ -59935,7 +59928,7 @@ var validateLists = ({
       if (!config2.isInternalDirective(node)) {
         if (!config2.schema.getDirective(directiveName)) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               "Encountered unknown directive: " + directiveName
             )
           );
@@ -59944,7 +59937,7 @@ var validateLists = ({
       }
       if (config2.isListOperationDirective(directiveName) && !listTypes.includes(config2.listNameFromDirective(directiveName))) {
         ctx.reportError(
-          new graphql23.GraphQLError(
+          new graphql24.GraphQLError(
             "Encountered directive referencing unknown list: " + directiveName
           )
         );
@@ -59955,7 +59948,7 @@ var validateLists = ({
 };
 function knownArguments(config2) {
   return function(ctx) {
-    const nativeValidator = graphql23.KnownArgumentNamesRule(ctx);
+    const nativeValidator = graphql24.KnownArgumentNamesRule(ctx);
     return {
       ...nativeValidator,
       Directive(directiveNode) {
@@ -59988,7 +59981,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         for (const arg of node.arguments || []) {
           if (arg.value.kind !== "ObjectValue") {
             ctx.reportError(
-              new graphql23.GraphQLError("values in @arguments must be an object")
+              new graphql24.GraphQLError("values in @arguments must be an object")
             );
             return;
           }
@@ -59998,13 +59991,13 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (!typeArg) {
             ctx.reportError(
-              new graphql23.GraphQLError("missing type field for @arguments directive")
+              new graphql24.GraphQLError("missing type field for @arguments directive")
             );
             return;
           }
-          if (typeArg.value.kind !== graphql23.Kind.STRING) {
+          if (typeArg.value.kind !== graphql24.Kind.STRING) {
             ctx.reportError(
-              new graphql23.GraphQLError("type field to @arguments must be a string")
+              new graphql24.GraphQLError("type field to @arguments must be a string")
             );
             return;
           }
@@ -60017,7 +60010,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (typeArg.value.value !== defaultValueType) {
             ctx.reportError(
-              new graphql23.GraphQLError(
+              new graphql24.GraphQLError(
                 `Invalid default value provided for ${arg.name.value}. Expected ${typeArg.value.value}, found ${defaultValueType}`
               )
             );
@@ -60035,7 +60028,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           try {
             args = fragmentArguments(config2, filepath, fragments[fragmentName]);
           } catch (e) {
-            ctx.reportError(new graphql23.GraphQLError(e.message));
+            ctx.reportError(new graphql24.GraphQLError(e.message));
             return;
           }
           fragmentArguments2[fragmentName] = args;
@@ -60058,7 +60051,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (missing.length > 0) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               "The following arguments are missing from this fragment: " + JSON.stringify(missing)
             )
           );
@@ -60069,7 +60062,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (unknown.length > 0) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               "Encountered unknown arguments: " + JSON.stringify(unknown)
             )
           );
@@ -60081,7 +60074,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             ]
           );
           for (const [applied, target] of zipped) {
-            if (applied.value.kind === graphql23.Kind.VARIABLE || applied.value.kind === graphql23.Kind.LIST || applied.value.kind === graphql23.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(
@@ -60090,7 +60083,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             );
             if (appliedType !== target) {
               ctx.reportError(
-                new graphql23.GraphQLError(
+                new graphql24.GraphQLError(
                   `Invalid argument type. Expected ${target}, found ${appliedType}`
                 )
               );
@@ -60111,7 +60104,7 @@ function paginateArgs(config2, filepath) {
         }
         if (alreadyPaginated) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               `@${config2.paginateDirective} can only appear in a document once.`
             )
           );
@@ -60126,7 +60119,7 @@ function paginateArgs(config2, filepath) {
         const hasRequiredArgs = definitionArgs.find((arg) => arg.required);
         if (hasRequiredArgs) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               "@paginate cannot appear on a document with required args"
             )
           );
@@ -60158,14 +60151,14 @@ function paginateArgs(config2, filepath) {
           const backwards = appliedArgs.has("last");
           if (!forward && !backwards) {
             ctx.reportError(
-              new graphql23.GraphQLError(
+              new graphql24.GraphQLError(
                 "A field with cursor-based pagination must have a first or last argument"
               )
             );
           }
           if (forward && backwards) {
             ctx.reportError(
-              new graphql23.GraphQLError(
+              new graphql24.GraphQLError(
                 `A field with cursor pagination cannot go forwards an backwards simultaneously`
               )
             );
@@ -60179,7 +60172,7 @@ function paginateArgs(config2, filepath) {
           );
           if (!appliedLimitArg) {
             ctx.reportError(
-              new graphql23.GraphQLError(
+              new graphql24.GraphQLError(
                 "A field with offset-based pagination must have a limit argument"
               )
             );
@@ -60195,20 +60188,20 @@ function noUnusedFragmentArguments(config2) {
     const args = /* @__PURE__ */ new Set();
     return {
       enter(node) {
-        if (node.kind === graphql23.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 === graphql23.Kind.VARIABLE) {
+        } else if (node.kind === graphql24.Kind.VARIABLE) {
           args.delete(node.name.value);
         }
       },
       leave(node) {
-        if (node.kind === graphql23.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql24.Kind.FRAGMENT_DEFINITION) {
           if (args.size > 0) {
             ctx.reportError(
-              new graphql23.GraphQLError(
+              new graphql24.GraphQLError(
                 "Encountered unused fragment arguments: " + [...args].join(",")
               )
             );
@@ -60244,7 +60237,7 @@ function nodeDirectives(config2, directives) {
         if (definition.kind === "OperationDefinition") {
           if (definition.operation !== "query") {
             ctx.reportError(
-              new graphql23.GraphQLError(
+              new graphql24.GraphQLError(
                 `@${node.name.value} must fall on a fragment or query document`
               )
             );
@@ -60256,7 +60249,7 @@ function nodeDirectives(config2, directives) {
         }
         if (!possibleNodes.includes(definitionType)) {
           ctx.reportError(
-            new graphql23.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
+            new graphql24.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
           );
         }
       }
@@ -60275,7 +60268,7 @@ function checkMutationOperation(config2) {
         );
         if (append && prepend) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               `You can't apply both @${config2.listPrependDirective} and @${config2.listAppendDirective} at the same time`
             )
           );
@@ -60289,7 +60282,7 @@ function checkMutationOperation(config2) {
         );
         if (parentId && allLists) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               `You can't apply both @${config2.listParentDirective} and @${config2.listAllListsDirective} at the same time`
             )
           );
@@ -60311,7 +60304,7 @@ function checkMaskDirective(config2) {
         );
         if (maskEnableDirective && maskDisableDirective) {
           ctx.reportError(
-            new graphql23.GraphQLError(
+            new graphql24.GraphQLError(
               `You can't apply both @${config2.maskEnableDirective} and @${config2.maskDisableDirective} at the same time`
             )
           );
@@ -60327,7 +60320,7 @@ function getAndVerifyNodeInterface(config2) {
   if (!nodeInterface) {
     return null;
   }
-  if (!graphql23.isInterfaceType(nodeInterface)) {
+  if (!graphql24.isInterfaceType(nodeInterface)) {
     displayInvalidNodeFieldMessage(config2.logLevel);
     return null;
   }
@@ -60425,11 +60418,11 @@ async function uniqueDocumentNames(config2, docs) {
 }
 
 // src/codegen/validators/noIDAlias.ts
-var graphql24 = __toESM(require_graphql2(), 1);
+var graphql25 = __toESM(require_graphql2(), 1);
 async function noIDAlias(config2, docs) {
   const errors = [];
   for (const { filename, document } of docs) {
-    graphql24.visit(document, {
+    graphql25.visit(document, {
       Field(node, _, __, ___, ancestors) {
         const fieldType = parentTypeFromAncestors(config2.schema, filename, ancestors).name;
         if (config2.keyFieldsForType(fieldType).includes(node.alias?.value || "")) {
@@ -60627,12 +60620,12 @@ async function processJSFile(config2, contents) {
   return documents;
 }
 async function processGraphQLDocument(config2, filepath, document) {
-  const parsedDoc = graphql25.parse(document);
+  const parsedDoc = graphql26.parse(document);
   const operations = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql25.Kind.OPERATION_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql26.Kind.OPERATION_DEFINITION
   );
   const fragments = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql25.Kind.FRAGMENT_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql26.Kind.FRAGMENT_DEFINITION
   );
   if (operations.length > 1) {
     throw new HoudiniError({