houdini 0.18.2 → 0.18.3

package/build/vite-cjs/index.js

@@ -4675,7 +4675,7 @@ var require_kinds = __commonJS({
       value: true
     });
     exports.Kind = void 0;
-    var Kind29 = Object.freeze({
+    var Kind30 = Object.freeze({
       NAME: "Name",
       DOCUMENT: "Document",
       OPERATION_DEFINITION: "OperationDefinition",
@@ -4720,7 +4720,7 @@ var require_kinds = __commonJS({
       ENUM_TYPE_EXTENSION: "EnumTypeExtension",
       INPUT_OBJECT_TYPE_EXTENSION: "InputObjectTypeExtension"
     });
-    exports.Kind = Kind29;
+    exports.Kind = Kind30;
   }
 });
 
@@ -13900,7 +13900,7 @@ var require_graphql = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.graphql = graphql28;
+    exports.graphql = graphql29;
     exports.graphqlSync = graphqlSync;
     var _isPromise = _interopRequireDefault(require_isPromise());
     var _parser = require_parser();
@@ -13910,7 +13910,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 graphql29(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) {
       var _arguments = arguments;
       return new Promise(function(resolve2) {
         return resolve2(
@@ -61938,7 +61938,7 @@ function watchAndRun(params) {
 }
 
 // src/codegen/index.ts
-var graphql27 = __toESM(require_graphql2(), 1);
+var graphql28 = __toESM(require_graphql2(), 1);
 
 // src/lib/pipeline.ts
 async function runPipeline(config4, pipeline2, target) {
@@ -69250,7 +69250,7 @@ async function find_graphql(config4, parsedScript, walker) {
 }
 
 // src/codegen/generators/artifacts/index.ts
-var graphql13 = __toESM(require_graphql2(), 1);
+var graphql14 = __toESM(require_graphql2(), 1);
 var recast5 = __toESM(require_main2(), 1);
 
 // src/codegen/utils/commonjs.ts
@@ -69854,7 +69854,7 @@ function ancestorKey(ancestors) {
 }
 
 // src/codegen/generators/artifacts/selection.ts
-var graphql12 = __toESM(require_graphql2(), 1);
+var graphql13 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.pnpm/@kitql+helper@0.5.0/node_modules/@kitql/helper/index.mjs
 var config2 = {
@@ -69900,10 +69900,24 @@ async function sleep2(ms) {
 }
 
 // src/codegen/transforms/list.ts
-var graphql10 = __toESM(require_graphql2(), 1);
+var graphql11 = __toESM(require_graphql2(), 1);
 
-// src/codegen/transforms/paginate.ts
+// src/codegen/utils/objectIdentificationSelection.ts
 var graphql9 = __toESM(require_graphql2(), 1);
+var objectIdentificationSelection = (config4, type) => {
+  return config4.keyFieldsForType(type.name).map((key) => {
+    return {
+      kind: graphql9.Kind.FIELD,
+      name: {
+        kind: graphql9.Kind.NAME,
+        value: key
+      }
+    };
+  });
+};
+
+// src/codegen/transforms/paginate.ts
+var graphql10 = __toESM(require_graphql2(), 1);
 async function paginate(config4, documents) {
   const newDocs = [];
   for (const doc of documents) {
@@ -69936,7 +69950,7 @@ async function paginate(config4, documents) {
     };
     let cursorType = "String";
     let paginationPath = [];
-    doc.document = graphql9.visit(doc.document, {
+    doc.document = graphql10.visit(doc.document, {
       Field(node, _, __, ___, ancestors) {
         const paginateDirective = node.directives?.find(
           (directive) => directive.name.value === config4.paginateDirective
@@ -69963,7 +69977,7 @@ async function paginate(config4, documents) {
         flags.offset.enabled = offsetPagination;
         flags.limit.enabled = offsetPagination;
         paginationPath = ancestors.filter(
-          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql9.Kind.FIELD
+          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql10.Kind.FIELD
         ).concat(node).map((field) => field.alias?.value || field.name.value);
         return {
           ...node,
@@ -69984,7 +69998,7 @@ async function paginate(config4, documents) {
         refetchUpdate = "prepend" /* prepend */;
       }
       let fragment = "";
-      doc.document = graphql9.visit(doc.document, {
+      doc.document = graphql10.visit(doc.document, {
         OperationDefinition(node) {
           if (node.operation !== "query") {
             throw new HoudiniError({
@@ -70038,9 +70052,9 @@ async function paginate(config4, documents) {
               directives: [
                 ...node.directives || [],
                 {
-                  kind: graphql9.Kind.DIRECTIVE,
+                  kind: graphql10.Kind.DIRECTIVE,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: config4.argumentsDirective
                   }
                 }
@@ -70103,16 +70117,16 @@ async function paginate(config4, documents) {
       const paginationArgs = Object.entries(flags).filter(([_, { enabled }]) => enabled).map(([key, value]) => ({ name: key, ...value }));
       const fragmentSpreadSelection = [
         {
-          kind: graphql9.Kind.FRAGMENT_SPREAD,
+          kind: graphql10.Kind.FRAGMENT_SPREAD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: fragmentName
           },
           directives: [
             {
-              kind: graphql9.Kind.DIRECTIVE,
+              kind: graphql10.Kind.DIRECTIVE,
               name: {
-                kind: graphql9.Kind.NAME,
+                kind: graphql10.Kind.NAME,
                 value: config4.withDirective
               },
               ["arguments"]: paginationArgs.map(
@@ -70140,29 +70154,29 @@ async function paginate(config4, documents) {
       });
       const typeConfig = config4.typeConfig?.[fragment];
       const queryDoc = {
-        kind: graphql9.Kind.DOCUMENT,
+        kind: graphql10.Kind.DOCUMENT,
         definitions: [
           {
-            kind: graphql9.Kind.OPERATION_DEFINITION,
+            kind: graphql10.Kind.OPERATION_DEFINITION,
             name: {
-              kind: graphql9.Kind.NAME,
+              kind: graphql10.Kind.NAME,
               value: refetchQueryName
             },
             operation: "query",
             variableDefinitions: paginationArgs.map(
               (arg) => ({
-                kind: graphql9.Kind.VARIABLE_DEFINITION,
+                kind: graphql10.Kind.VARIABLE_DEFINITION,
                 type: {
-                  kind: graphql9.Kind.NAMED_TYPE,
+                  kind: graphql10.Kind.NAMED_TYPE,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: arg.type
                   }
                 },
                 variable: {
-                  kind: graphql9.Kind.VARIABLE,
+                  kind: graphql10.Kind.VARIABLE,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: arg.name
                   }
                 },
@@ -70174,12 +70188,12 @@ async function paginate(config4, documents) {
             ).concat(
               !nodeQuery ? [] : keys.map(
                 (key) => ({
-                  kind: graphql9.Kind.VARIABLE_DEFINITION,
+                  kind: graphql10.Kind.VARIABLE_DEFINITION,
                   type: key.type,
                   variable: {
-                    kind: graphql9.Kind.VARIABLE,
+                    kind: graphql10.Kind.VARIABLE,
                     name: {
-                      kind: graphql9.Kind.NAME,
+                      kind: graphql10.Kind.NAME,
                       value: key.name
                     }
                   }
@@ -70187,42 +70201,42 @@ async function paginate(config4, documents) {
               )
             ),
             selectionSet: {
-              kind: graphql9.Kind.SELECTION_SET,
+              kind: graphql10.Kind.SELECTION_SET,
               selections: !nodeQuery ? fragmentSpreadSelection : [
                 {
-                  kind: graphql9.Kind.FIELD,
+                  kind: graphql10.Kind.FIELD,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: typeConfig?.resolve?.queryField || "node"
                   },
                   ["arguments"]: keys.map((key) => ({
-                    kind: graphql9.Kind.ARGUMENT,
+                    kind: graphql10.Kind.ARGUMENT,
                     name: {
-                      kind: graphql9.Kind.NAME,
+                      kind: graphql10.Kind.NAME,
                       value: key.name
                     },
                     value: {
-                      kind: graphql9.Kind.VARIABLE,
+                      kind: graphql10.Kind.VARIABLE,
                       name: {
-                        kind: graphql9.Kind.NAME,
+                        kind: graphql10.Kind.NAME,
                         value: key.name
                       }
                     }
                   })),
                   selectionSet: {
-                    kind: graphql9.Kind.SELECTION_SET,
+                    kind: graphql10.Kind.SELECTION_SET,
                     selections: [
                       {
-                        kind: graphql9.Kind.FIELD,
+                        kind: graphql10.Kind.FIELD,
                         name: {
-                          kind: graphql9.Kind.NAME,
+                          kind: graphql10.Kind.NAME,
                           value: "__typename"
                         }
                       },
                       ...(typeConfig?.keys || ["id"]).map((key) => ({
-                        kind: graphql9.Kind.FIELD,
+                        kind: graphql10.Kind.FIELD,
                         name: {
-                          kind: graphql9.Kind.NAME,
+                          kind: graphql10.Kind.NAME,
                           value: key
                         }
                       })),
@@ -70284,15 +70298,15 @@ function replaceArgumentsWithVariables(args, flags) {
 }
 function variableAsArgument(name2, variable) {
   return {
-    kind: graphql9.Kind.ARGUMENT,
+    kind: graphql10.Kind.ARGUMENT,
     name: {
-      kind: graphql9.Kind.NAME,
+      kind: graphql10.Kind.NAME,
       value: name2
     },
     value: {
-      kind: graphql9.Kind.VARIABLE,
+      kind: graphql10.Kind.VARIABLE,
       name: {
-        kind: graphql9.Kind.NAME,
+        kind: graphql10.Kind.NAME,
         value: variable ?? name2
       }
     }
@@ -70300,18 +70314,18 @@ function variableAsArgument(name2, variable) {
 }
 function staticVariableDefinition(name2, type, defaultValue, variableName) {
   return {
-    kind: graphql9.Kind.VARIABLE_DEFINITION,
+    kind: graphql10.Kind.VARIABLE_DEFINITION,
     type: {
-      kind: graphql9.Kind.NAMED_TYPE,
+      kind: graphql10.Kind.NAMED_TYPE,
       name: {
-        kind: graphql9.Kind.NAME,
+        kind: graphql10.Kind.NAME,
         value: type
       }
     },
     variable: {
-      kind: graphql9.Kind.VARIABLE,
+      kind: graphql10.Kind.VARIABLE,
       name: {
-        kind: graphql9.Kind.NAME,
+        kind: graphql10.Kind.NAME,
         value: variableName ?? name2
       }
     },
@@ -70323,9 +70337,9 @@ function staticVariableDefinition(name2, type, defaultValue, variableName) {
 }
 function argumentNode(name2, value) {
   return {
-    kind: graphql9.Kind.ARGUMENT,
+    kind: graphql10.Kind.ARGUMENT,
     name: {
-      kind: graphql9.Kind.NAME,
+      kind: graphql10.Kind.NAME,
       value: name2
     },
     value: objectNode(value)
@@ -70333,16 +70347,16 @@ function argumentNode(name2, value) {
 }
 function objectNode([type, defaultValue]) {
   const node = {
-    kind: graphql9.Kind.OBJECT,
+    kind: graphql10.Kind.OBJECT,
     fields: [
       {
-        kind: graphql9.Kind.OBJECT_FIELD,
+        kind: graphql10.Kind.OBJECT_FIELD,
         name: {
-          kind: graphql9.Kind.NAME,
+          kind: graphql10.Kind.NAME,
           value: "type"
         },
         value: {
-          kind: graphql9.Kind.STRING,
+          kind: graphql10.Kind.STRING,
           value: type
         }
       }
@@ -70350,8 +70364,8 @@ function objectNode([type, defaultValue]) {
   };
   if (defaultValue) {
     node.fields.push({
-      kind: graphql9.Kind.OBJECT_FIELD,
-      name: { kind: graphql9.Kind.NAME, value: "default" },
+      kind: graphql10.Kind.OBJECT_FIELD,
+      name: { kind: graphql10.Kind.NAME, value: "default" },
       value: {
         kind: typeof defaultValue === "number" ? "IntValue" : "StringValue",
         value: defaultValue.toString()
@@ -70362,34 +70376,34 @@ function objectNode([type, defaultValue]) {
 }
 var pageInfoSelection = [
   {
-    kind: graphql9.Kind.FIELD,
+    kind: graphql10.Kind.FIELD,
     name: {
-      kind: graphql9.Kind.NAME,
+      kind: graphql10.Kind.NAME,
       value: "edges"
     },
     selectionSet: {
-      kind: graphql9.Kind.SELECTION_SET,
+      kind: graphql10.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "cursor"
           }
         },
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "node"
           },
           selectionSet: {
-            kind: graphql9.Kind.SELECTION_SET,
+            kind: graphql10.Kind.SELECTION_SET,
             selections: [
               {
-                kind: graphql9.Kind.FIELD,
+                kind: graphql10.Kind.FIELD,
                 name: {
-                  kind: graphql9.Kind.NAME,
+                  kind: graphql10.Kind.NAME,
                   value: "__typename"
                 }
               }
@@ -70400,39 +70414,39 @@ var pageInfoSelection = [
     }
   },
   {
-    kind: graphql9.Kind.FIELD,
+    kind: graphql10.Kind.FIELD,
     name: {
-      kind: graphql9.Kind.NAME,
+      kind: graphql10.Kind.NAME,
       value: "pageInfo"
     },
     selectionSet: {
-      kind: graphql9.Kind.SELECTION_SET,
+      kind: graphql10.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "hasPreviousPage"
           }
         },
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "hasNextPage"
           }
         },
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "startCursor"
           }
         },
         {
-          kind: graphql9.Kind.FIELD,
+          kind: graphql10.Kind.FIELD,
           name: {
-            kind: graphql9.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "endCursor"
           }
         }
@@ -70446,15 +70460,15 @@ async function addListFragments(config4, documents) {
   const lists = {};
   const errors = [];
   for (const doc of documents) {
-    doc.document = graphql10.visit(doc.document, {
+    doc.document = graphql11.visit(doc.document, {
       Directive(node, key, parent, path2, ancestors) {
         if ([config4.listDirective, config4.paginateDirective].includes(node.name.value)) {
           const nameArg = node.arguments?.find((arg) => arg.name.value === "name");
           let error = {
-            ...new graphql10.GraphQLError(
+            ...new graphql11.GraphQLError(
               "",
               node,
-              new graphql10.Source(""),
+              new graphql11.Source(""),
               node.loc ? [node.loc.start, node.loc.end] : null,
               path2
             ),
@@ -70506,7 +70520,7 @@ async function addListFragments(config4, documents) {
                 {
                   kind: "Argument",
                   name: {
-                    kind: graphql10.Kind.NAME,
+                    kind: graphql11.Kind.NAME,
                     value: "connection"
                   },
                   value: {
@@ -70553,10 +70567,13 @@ async function addListFragments(config4, documents) {
   if (errors.length > 0) {
     throw errors;
   }
-  const listTargets = [
+  const validDeletes = [
     ...new Set(
       Object.values(lists).map(({ type }) => {
-        if (!(type instanceof graphql10.GraphQLObjectType)) {
+        if (!(type instanceof graphql11.GraphQLObjectType)) {
+          return "";
+        }
+        if (config4.keyFieldsForType(type.name).length !== 1) {
           return "";
         }
         return type.name;
@@ -70567,7 +70584,7 @@ async function addListFragments(config4, documents) {
     return;
   }
   const generatedDoc = {
-    kind: graphql10.Kind.DOCUMENT,
+    kind: graphql11.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
       ([name2, { selection: selection2, type }]) => {
         const schemaType = config4.schema.getType(type.name);
@@ -70575,35 +70592,29 @@ async function addListFragments(config4, documents) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
-          kind: graphql10.Kind.SELECTION_SET,
+          kind: graphql11.Kind.SELECTION_SET,
           selections: [...selection2.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
-          (field) => field.kind === "Field" && field.name.value === "id"
+          (field) => field.kind === "Field" && config4.keyFieldsForType(type.name).includes(field.name.value)
         )) {
           fragmentSelection.selections = [
             ...fragmentSelection.selections,
-            {
-              kind: graphql10.Kind.FIELD,
-              name: {
-                kind: graphql10.Kind.NAME,
-                value: "id"
-              }
-            }
+            ...objectIdentificationSelection(config4, type)
           ];
         }
         return [
           {
             name: {
               value: config4.listInsertFragment(name2),
-              kind: graphql10.Kind.NAME
+              kind: graphql11.Kind.NAME
             },
-            kind: graphql10.Kind.FRAGMENT_DEFINITION,
+            kind: graphql11.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql10.Kind.NAMED_TYPE,
+              kind: graphql11.Kind.NAMED_TYPE,
               name: {
-                kind: graphql10.Kind.NAME,
+                kind: graphql11.Kind.NAME,
                 value: type.name
               }
             }
@@ -70611,52 +70622,32 @@ async function addListFragments(config4, documents) {
           {
             name: {
               value: config4.listToggleFragment(name2),
-              kind: graphql10.Kind.NAME
-            },
-            kind: graphql10.Kind.FRAGMENT_DEFINITION,
-            selectionSet: {
-              ...fragmentSelection,
-              selections: [
-                ...fragmentSelection.selections,
-                {
-                  kind: graphql10.Kind.FIELD,
-                  name: {
-                    kind: graphql10.Kind.NAME,
-                    value: "id"
-                  }
-                }
-              ]
+              kind: graphql11.Kind.NAME
             },
+            kind: graphql11.Kind.FRAGMENT_DEFINITION,
+            selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql10.Kind.NAMED_TYPE,
+              kind: graphql11.Kind.NAMED_TYPE,
               name: {
-                kind: graphql10.Kind.NAME,
+                kind: graphql11.Kind.NAME,
                 value: type.name
               }
             }
           },
           {
-            kind: graphql10.Kind.FRAGMENT_DEFINITION,
+            kind: graphql11.Kind.FRAGMENT_DEFINITION,
             name: {
               value: config4.listRemoveFragment(name2),
-              kind: graphql10.Kind.NAME
+              kind: graphql11.Kind.NAME
             },
             selectionSet: {
-              kind: graphql10.Kind.SELECTION_SET,
-              selections: [
-                {
-                  kind: graphql10.Kind.FIELD,
-                  name: {
-                    kind: graphql10.Kind.NAME,
-                    value: "id"
-                  }
-                }
-              ]
+              kind: graphql11.Kind.SELECTION_SET,
+              selections: [...objectIdentificationSelection(config4, type)]
             },
             typeCondition: {
-              kind: graphql10.Kind.NAMED_TYPE,
+              kind: graphql11.Kind.NAMED_TYPE,
               name: {
-                kind: graphql10.Kind.NAME,
+                kind: graphql11.Kind.NAME,
                 value: type.name
               }
             }
@@ -70664,15 +70655,15 @@ async function addListFragments(config4, documents) {
         ];
       }
     ).concat(
-      ...listTargets.map((typeName) => ({
-        kind: graphql10.Kind.DIRECTIVE_DEFINITION,
+      ...validDeletes.map((typeName) => ({
+        kind: graphql11.Kind.DIRECTIVE_DEFINITION,
         name: {
-          kind: graphql10.Kind.NAME,
+          kind: graphql11.Kind.NAME,
           value: config4.listDeleteDirective(typeName)
         },
         locations: [
           {
-            kind: graphql10.Kind.NAME,
+            kind: graphql11.Kind.NAME,
             value: "FIELD"
           }
         ],
@@ -70680,8 +70671,8 @@ async function addListFragments(config4, documents) {
       }))
     )
   };
-  config4.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql10.print).join("\n\n");
-  config4.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql10.print).join("\n\n");
+  config4.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql11.print).join("\n\n");
+  config4.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql11.print).join("\n\n");
   documents.push({
     name: "generated::lists",
     kind: "HoudiniFragment" /* Fragment */,
@@ -70766,11 +70757,11 @@ var nodeNotDefinedMessage = (config4) => `Looks like you are trying to use the $
 For more information, visit this link: ${siteURL}/guides/pagination`;
 
 // src/codegen/generators/artifacts/fieldKey.ts
-var graphql11 = __toESM(require_graphql2(), 1);
+var graphql12 = __toESM(require_graphql2(), 1);
 function fieldKey(config4, field) {
   const attributeName = field.alias?.value || field.name.value;
-  const printed = graphql11.print(field);
-  const secondParse = graphql11.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
+  const printed = graphql12.print(field);
+  const secondParse = graphql12.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
   const paginated = !!field.directives?.find(
     (directive) => directive.name.value === config4.paginateDirective
   );
@@ -70863,8 +70854,8 @@ function selection({
         const typeConditionName = field.typeCondition.name.value;
         const typeCondition = config4.schema.getType(typeConditionName);
         const possibleTypes = [];
-        if (!graphql12.isAbstractType(typeCondition)) {
-        } else if (graphql12.isAbstractType(parentType)) {
+        if (!graphql13.isAbstractType(typeCondition)) {
+        } else if (graphql13.isAbstractType(parentType)) {
           const possibleParentTypes = config4.schema.getPossibleTypes(parentType).map((type) => type.name);
           for (const possible of config4.schema.getPossibleTypes(typeCondition)) {
             if (possibleParentTypes.includes(possible.name)) {
@@ -70912,7 +70903,7 @@ function selection({
       } else {
         let typeRef = type.getFields()[field.name.value].type;
         fieldType = getRootType(typeRef);
-        nullable = !graphql12.isNonNullType(typeRef);
+        nullable = !graphql13.isNonNullType(typeRef);
       }
       const typeName = fieldType.toString();
       const pathSoFar = path2.concat(attributeName);
@@ -70977,7 +70968,7 @@ function selection({
           {}
         );
       }
-      if (graphql12.isInterfaceType(fieldType) || graphql12.isUnionType(fieldType)) {
+      if (graphql13.isInterfaceType(fieldType) || graphql13.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
       object.fields = {
@@ -71034,7 +71025,7 @@ function artifactGenerator(stats) {
   return async function(config4, docs) {
     const filterTypes = {};
     for (const doc of docs) {
-      graphql13.visit(doc.document, {
+      graphql14.visit(doc.document, {
         Directive(node, _, __, ___, ancestors) {
           if (node.name.value !== config4.listDirective) {
             return;
@@ -71093,7 +71084,7 @@ function artifactGenerator(stats) {
             return;
           }
           const usedVariableNames = /* @__PURE__ */ new Set();
-          let documentWithoutInternalDirectives = graphql13.visit(document, {
+          let documentWithoutInternalDirectives = graphql14.visit(document, {
             Directive(node) {
               if (config4.isInternalDirective(node)) {
                 return null;
@@ -71106,7 +71097,7 @@ function artifactGenerator(stats) {
               }
             }
           });
-          let documentWithoutExtraVariables = graphql13.visit(
+          let documentWithoutExtraVariables = graphql14.visit(
             documentWithoutInternalDirectives,
             {
               VariableDefinition(variableDefinitionNode) {
@@ -71117,13 +71108,13 @@ function artifactGenerator(stats) {
               }
             }
           );
-          let rawString = graphql13.print(documentWithoutExtraVariables);
+          let rawString = graphql14.print(documentWithoutExtraVariables);
           let docKind = doc.kind;
           const operations = document.definitions.filter(
-            ({ kind }) => kind === graphql13.Kind.OPERATION_DEFINITION
+            ({ kind }) => kind === graphql14.Kind.OPERATION_DEFINITION
           );
           const fragments = document.definitions.filter(
-            ({ kind }) => kind === graphql13.Kind.FRAGMENT_DEFINITION
+            ({ kind }) => kind === graphql14.Kind.FRAGMENT_DEFINITION
           );
           let rootType = "";
           let selectionSet;
@@ -71310,15 +71301,15 @@ async function generatePluginRuntime(config4, plugin) {
 var recast10 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/addReferencedInputTypes.ts
-var graphql16 = __toESM(require_graphql2(), 1);
+var graphql17 = __toESM(require_graphql2(), 1);
 var recast8 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/typeReference.ts
-var graphql15 = __toESM(require_graphql2(), 1);
+var graphql16 = __toESM(require_graphql2(), 1);
 var recast7 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/types.ts
-var graphql14 = __toESM(require_graphql2(), 1);
+var graphql15 = __toESM(require_graphql2(), 1);
 var recast6 = __toESM(require_main2(), 1);
 var AST6 = recast6.types.builders;
 function readonlyProperty(prop, enable = true) {
@@ -71352,7 +71343,7 @@ function scalarPropertyValue(config4, missingScalars, target) {
       return AST6.tsStringKeyword();
     }
     default: {
-      if (graphql14.isNonNullType(target) && "ofType" in target) {
+      if (graphql15.isNonNullType(target) && "ofType" in target) {
         return scalarPropertyValue(
           config4,
           missingScalars,
@@ -71373,7 +71364,7 @@ var AST7 = recast7.types.builders;
 function tsTypeReference(config4, missingScalars, definition) {
   const { type, wrappers } = unwrapType(config4, definition.type);
   let result;
-  if (graphql15.isScalarType(type)) {
+  if (graphql16.isScalarType(type)) {
     result = scalarPropertyValue(config4, missingScalars, type);
   } else {
     result = AST7.tsTypeReference(AST7.identifier(type.name));
@@ -71394,17 +71385,17 @@ function tsTypeReference(config4, missingScalars, definition) {
 var AST8 = recast8.types.builders;
 function addReferencedInputTypes(config4, filepath, body, visitedTypes, missingScalars, rootType) {
   const { type } = unwrapType(config4, rootType);
-  if (graphql16.isScalarType(type)) {
+  if (graphql17.isScalarType(type)) {
     return;
   }
   if (visitedTypes.has(type.name)) {
     return;
   }
-  if (graphql16.isUnionType(type)) {
+  if (graphql17.isUnionType(type)) {
     throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
   }
   visitedTypes.add(type.name);
-  if (graphql16.isEnumType(type)) {
+  if (graphql17.isEnumType(type)) {
     ensureImports({
       config: config4,
       body,
@@ -71421,7 +71412,7 @@ function addReferencedInputTypes(config4, filepath, body, visitedTypes, missingS
       AST8.tsPropertySignature(
         AST8.identifier(field.name),
         AST8.tsTypeAnnotation(tsTypeReference(config4, missingScalars, field)),
-        graphql16.isNullableType(field.type)
+        graphql17.isNullableType(field.type)
       )
     );
   }
@@ -71429,7 +71420,7 @@ function addReferencedInputTypes(config4, filepath, body, visitedTypes, missingS
 }
 
 // src/codegen/generators/typescript/inlineType.ts
-var graphql17 = __toESM(require_graphql2(), 1);
+var graphql18 = __toESM(require_graphql2(), 1);
 var recast9 = __toESM(require_main2(), 1);
 var AST9 = recast9.types.builders;
 var fragmentKey = "$fragments";
@@ -71448,9 +71439,9 @@ function inlineType({
 }) {
   const { type, wrappers } = unwrapType(config4, rootType);
   let result;
-  if (graphql17.isScalarType(type)) {
+  if (graphql18.isScalarType(type)) {
     result = scalarPropertyValue(config4, missingScalars, type);
-  } else if (graphql17.isEnumType(type)) {
+  } else if (graphql18.isEnumType(type)) {
     if (!visitedTypes.has(type.name)) {
       ensureImports({
         config: config4,
@@ -71468,11 +71459,11 @@ function inlineType({
     for (const selection2 of selections) {
       if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
         const fragmentType = config4.schema.getType(selection2.typeCondition.name.value);
-        if (!graphql17.isInterfaceType(type) && !graphql17.isUnionType(type)) {
+        if (!graphql18.isInterfaceType(type) && !graphql18.isUnionType(type)) {
           selectedFields.push(...selection2.selectionSet.selections);
           continue;
         }
-        if (!graphql17.isInterfaceType(fragmentType) && !graphql17.isUnionType(fragmentType)) {
+        if (!graphql18.isInterfaceType(fragmentType) && !graphql18.isUnionType(fragmentType)) {
           if (!inlineFragments[fragmentType.name]) {
             inlineFragments[fragmentType.name] = [];
           }
@@ -71592,7 +71583,7 @@ function inlineType({
           }
         }
       }
-      if (objectType.type === "TSTypeLiteral" && !graphql17.isInterfaceType(fragmentRootType) && !graphql17.isUnionType(fragmentRootType)) {
+      if (objectType.type === "TSTypeLiteral" && !graphql18.isInterfaceType(fragmentRootType) && !graphql18.isUnionType(fragmentRootType)) {
         const existingTypenameIndex = objectType.members.findIndex(
           (member) => member.type === "TSPropertySignature" && member.key.type === "Identifier" && member.key.name === "__typename"
         );
@@ -71659,7 +71650,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection2) {
       },
       type: schema.getType("String")
     };
-  } else if (graphql17.isNonNullType(rootType) && "getFields" in rootType.ofType) {
+  } else if (graphql18.isNonNullType(rootType) && "getFields" in rootType.ofType) {
     fields = rootType.ofType.getFields();
   } else {
     fields = rootType.getFields();
@@ -71671,7 +71662,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 = graphql18.getNamedType(field.type);
   if (!fieldType) {
     throw new HoudiniError({
       filepath,
@@ -71991,7 +71982,7 @@ async function generateFragmentTypeDefs(config4, filepath, body, selections, def
 }
 
 // src/codegen/generators/persistedQueries/index.ts
-var graphql18 = __toESM(require_graphql2(), 1);
+var graphql19 = __toESM(require_graphql2(), 1);
 async function persistOutputGenerator(config4, docs) {
   if (typeof config4.persistedQueryPath !== "string" || config4.persistedQueryPath.length === 0)
     return;
@@ -72003,8 +71994,8 @@ async function persistOutputGenerator(config4, docs) {
     if (!generateArtifact) {
       return acc;
     }
-    let rawString = graphql18.print(
-      graphql18.visit(document, {
+    let rawString = graphql19.print(
+      graphql19.visit(document, {
         Directive(node) {
           if (config4.isInternalDirective(node)) {
             return null;
@@ -72013,7 +72004,7 @@ async function persistOutputGenerator(config4, docs) {
       })
     );
     const operations = document.definitions.filter(
-      ({ kind }) => kind === graphql18.Kind.OPERATION_DEFINITION
+      ({ kind }) => kind === graphql19.Kind.OPERATION_DEFINITION
     );
     if (operations.length > 0 && operations[0].kind === "OperationDefinition") {
       acc[hashDocument(rawString)] = rawString;
@@ -72026,11 +72017,11 @@ async function persistOutputGenerator(config4, docs) {
 }
 
 // src/codegen/generators/definitions/enums.ts
-var graphql19 = __toESM(require_graphql2(), 1);
+var graphql20 = __toESM(require_graphql2(), 1);
 var recast11 = __toESM(require_main2(), 1);
 var AST11 = recast11.types.builders;
 async function definitionsGenerator(config4) {
-  const enums = graphql19.parse(graphql19.printSchema(config4.schema)).definitions.filter(
+  const enums = graphql20.parse(graphql20.printSchema(config4.schema)).definitions.filter(
     (definition) => definition.kind === "EnumTypeDefinition"
   ).filter((def) => !config4.isInternalEnum(def));
   const runtimeDefinitions = recast11.print(
@@ -72203,7 +72194,7 @@ function flattenFragments(filepath, operation, fragments) {
 }
 
 // src/codegen/transforms/schema.ts
-var graphql21 = __toESM(require_graphql2(), 1);
+var graphql22 = __toESM(require_graphql2(), 1);
 async function graphqlExtensions(config4, documents) {
   const internalSchema = `
 enum CachePolicy {
@@ -72281,19 +72272,19 @@ directive @${config4.maskEnableDirective} on FRAGMENT_SPREAD
 """
 directive @${config4.maskDisableDirective} on FRAGMENT_SPREAD
 `;
-  let currentSchema = graphql21.printSchema(config4.schema);
+  let currentSchema = graphql22.printSchema(config4.schema);
   if (!currentSchema.includes(`directive @${config4.listDirective}`)) {
     currentSchema += internalSchema;
   }
   config4.newSchema += internalSchema;
-  config4.schema = graphql21.buildSchema(currentSchema);
+  config4.schema = graphql22.buildSchema(currentSchema);
 }
 
 // src/codegen/transforms/typename.ts
-var graphql22 = __toESM(require_graphql2(), 1);
+var graphql23 = __toESM(require_graphql2(), 1);
 async function addTypename(config4, documents) {
   for (const doc of documents) {
-    doc.document = graphql22.visit(doc.document, {
+    doc.document = graphql23.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -72305,7 +72296,7 @@ async function addTypename(config4, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config4, field.type).type;
-        if (graphql22.isInterfaceType(fieldType) || graphql22.isUnionType(fieldType)) {
+        if (graphql23.isInterfaceType(fieldType) || graphql23.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -72313,9 +72304,9 @@ async function addTypename(config4, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql22.Kind.FIELD,
+                  kind: graphql23.Kind.FIELD,
                   name: {
-                    kind: graphql22.Kind.NAME,
+                    kind: graphql23.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -72329,10 +72320,10 @@ async function addTypename(config4, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql23 = __toESM(require_graphql2(), 1);
+var graphql24 = __toESM(require_graphql2(), 1);
 async function addID(config4, documents) {
   for (const doc of documents) {
-    doc.document = graphql23.visit(doc.document, {
+    doc.document = graphql24.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -72345,7 +72336,7 @@ async function addID(config4, documents) {
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config4, field.type).type;
         if (node.selectionSet?.selections.length > 0) {
-          if (!graphql23.isObjectType(fieldType) && !graphql23.isInterfaceType(fieldType)) {
+          if (!graphql24.isObjectType(fieldType) && !graphql24.isInterfaceType(fieldType)) {
             return;
           }
           const keyFields = config4.keyFieldsForType(fieldType.name);
@@ -72360,9 +72351,9 @@ async function addID(config4, documents) {
               continue;
             }
             selections.push({
-              kind: graphql23.Kind.FIELD,
+              kind: graphql24.Kind.FIELD,
               name: {
-                kind: graphql23.Kind.NAME,
+                kind: graphql24.Kind.NAME,
                 value: keyField
               }
             });
@@ -72381,8 +72372,8 @@ async function addID(config4, documents) {
 }
 
 // src/codegen/transforms/fragmentVariables.ts
-var graphql24 = __toESM(require_graphql2(), 1);
-var GraphqlKinds2 = graphql24.Kind;
+var graphql25 = __toESM(require_graphql2(), 1);
+var GraphqlKinds2 = graphql25.Kind;
 async function fragmentVariables(config4, documents) {
   const fragments = collectFragments(config4, documents);
   const generatedFragments = {};
@@ -72405,7 +72396,7 @@ async function fragmentVariables(config4, documents) {
     });
   }
   const doc = {
-    kind: graphql24.Kind.DOCUMENT,
+    kind: graphql25.Kind.DOCUMENT,
     definitions: Object.values(generatedFragments)
   };
   documents.push({
@@ -72441,7 +72432,7 @@ function inlineFragmentArgs({
     filepath,
     document
   ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
-  const result = graphql24.visit(document, {
+  const result = graphql25.visit(document, {
     FragmentSpread(node) {
       const { definition } = fragmentDefinitions[node.name.value];
       let { args, hash } = collectWithArguments(config4, filepath, node, scope);
@@ -72529,7 +72520,7 @@ function inlineFragmentArgs({
   });
   if (newName) {
     result.name = {
-      kind: graphql24.Kind.NAME,
+      kind: graphql25.Kind.NAME,
       value: newName
     };
   }
@@ -72641,7 +72632,7 @@ function operationScope(operation) {
 }
 
 // src/codegen/validators/typeCheck.ts
-var graphql25 = __toESM(require_graphql2(), 1);
+var graphql26 = __toESM(require_graphql2(), 1);
 async function typeCheck(config4, docs) {
   const errors = [];
   const freeLists = [];
@@ -72649,11 +72640,11 @@ async function typeCheck(config4, docs) {
   const listTypes = [];
   const fragments = {};
   for (const { document: parsed, filename } of docs) {
-    graphql25.visit(parsed, {
-      [graphql25.Kind.FRAGMENT_DEFINITION](definition) {
+    graphql26.visit(parsed, {
+      [graphql26.Kind.FRAGMENT_DEFINITION](definition) {
         fragments[definition.name.value] = definition;
       },
-      [graphql25.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
+      [graphql26.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
         if (![config4.listDirective, config4.paginateDirective].includes(directive.name.value)) {
           return;
         }
@@ -72699,14 +72690,14 @@ async function typeCheck(config4, docs) {
             );
             return;
           }
-          if (graphql25.isListType(rootType) || graphql25.isNonNullType(rootType) && graphql25.isListType(rootType.ofType)) {
+          if (graphql26.isListType(rootType) || graphql26.isNonNullType(rootType) && graphql26.isListType(rootType.ofType)) {
             needsParent = true;
             break;
           }
-          if (graphql25.isNonNullType(rootType) && "ofType" in rootType) {
+          if (graphql26.isNonNullType(rootType) && "ofType" in rootType) {
             rootType = rootType.ofType;
           }
-          if (graphql25.isScalarType(rootType)) {
+          if (graphql26.isScalarType(rootType)) {
             break;
           }
           rootType = rootType?.getFields()[parent2.name.value]?.type;
@@ -72762,7 +72753,7 @@ async function typeCheck(config4, docs) {
         );
         const targetField = ancestors[ancestors.length - 1];
         const targetFieldDefinition = pType.getFields()[targetField.name.value];
-        const { type, error } = connectionSelection(
+        const { type, error: errorConnectionSelection } = connectionSelection(
           config4,
           targetFieldDefinition,
           parentTypeFromAncestors(
@@ -72772,10 +72763,19 @@ async function typeCheck(config4, docs) {
           ),
           targetField.selectionSet
         );
+        if (errorConnectionSelection && directive.name.value === config4.paginateDirective) {
+          errors.push(
+            new HoudiniError({
+              filepath: filename,
+              message: errorConnectionSelection,
+              description: errorConnectionSelection
+            })
+          );
+        }
         let targetTypes = [type];
-        if (graphql25.isUnionType(type)) {
+        if (graphql26.isUnionType(type)) {
           targetTypes = config4.schema.getPossibleTypes(type);
-        } else if (graphql25.isInterfaceType(type)) {
+        } else if (graphql26.isInterfaceType(type)) {
           try {
             for (const key of config4.keyFieldsForType(type.name)) {
               if (!type.getFields()[key]) {
@@ -72789,23 +72789,16 @@ async function typeCheck(config4, docs) {
         for (const targetType of targetTypes) {
           const missingIDFields = config4.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: `@${config4.listDirective} can only be applied to types with the necessary id fields: ${missingIDFields.join(
-                    ", "
-                  )}.`
-                })
-              );
-            }
+            const message = `@${config4.listDirective} on ${logGreen2(
+              targetType.name
+            )} as a configuration issue. Object identification missing: ${missingIDFields.map((c) => `"${logYellow2(c)}"`).join(", ")}. Check 'Custom IDs' if needed.`;
+            errors.push(
+              new HoudiniError({
+                filepath: filename,
+                message,
+                description: message
+              })
+            );
             return;
           }
         }
@@ -72820,13 +72813,13 @@ async function typeCheck(config4, docs) {
   if (errors.length > 0) {
     throw errors;
   }
-  const rules = (filepath) => [...graphql25.specifiedRules].filter(
+  const rules = (filepath) => [...graphql26.specifiedRules].filter(
     (rule) => ![
-      graphql25.NoUnusedFragmentsRule,
-      graphql25.KnownFragmentNamesRule,
-      graphql25.ExecutableDefinitionsRule,
-      graphql25.KnownDirectivesRule,
-      graphql25.KnownArgumentNamesRule
+      graphql26.NoUnusedFragmentsRule,
+      graphql26.KnownFragmentNamesRule,
+      graphql26.ExecutableDefinitionsRule,
+      graphql26.KnownDirectivesRule,
+      graphql26.KnownArgumentNamesRule
     ].includes(rule)
   ).concat(
     validateLists({
@@ -72845,7 +72838,7 @@ async function typeCheck(config4, docs) {
     noUnusedFragmentArguments(config4)
   );
   for (const { filename, document: parsed } of docs) {
-    for (const error of graphql25.validate(config4.schema, parsed, rules(filename))) {
+    for (const error of graphql26.validate(config4.schema, parsed, rules(filename))) {
       errors.push(
         new HoudiniError({
           filepath: filename,
@@ -72871,7 +72864,7 @@ var validateLists = ({
       if (!config4.isListFragment(node.name.value)) {
         if (!fragments[node.name.value]) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown fragment: " + node.name.value
             )
           );
@@ -72881,7 +72874,7 @@ var validateLists = ({
       const listName = config4.listNameFromFragment(node.name.value);
       if (!lists.includes(listName)) {
         ctx.reportError(
-          new graphql25.GraphQLError(
+          new graphql26.GraphQLError(
             "Encountered fragment referencing unknown list: " + listName
           )
         );
@@ -72906,7 +72899,7 @@ var validateLists = ({
         );
         if (parentArg) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `@${config4.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
             )
           );
@@ -72922,7 +72915,7 @@ var validateLists = ({
         return;
       }
       ctx.reportError(
-        new graphql25.GraphQLError(
+        new graphql26.GraphQLError(
           `For this list fragment, you need to add or @${config4.listParentDirective} or @${config4.listAllListsDirective} directive to specify the behavior`
         )
       );
@@ -72932,7 +72925,7 @@ var validateLists = ({
       const directiveName = node.name.value;
       if (directiveName === "connection") {
         ctx.reportError(
-          new graphql25.GraphQLError(
+          new graphql26.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."
           )
         );
@@ -72941,7 +72934,7 @@ var validateLists = ({
       if (!config4.isInternalDirective(node)) {
         if (!config4.schema.getDirective(directiveName)) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown directive: " + directiveName
             )
           );
@@ -72950,7 +72943,7 @@ var validateLists = ({
       }
       if (config4.isListOperationDirective(directiveName) && !listTypes.includes(config4.listNameFromDirective(directiveName))) {
         ctx.reportError(
-          new graphql25.GraphQLError(
+          new graphql26.GraphQLError(
             "Encountered directive referencing unknown list: " + directiveName
           )
         );
@@ -72961,7 +72954,7 @@ var validateLists = ({
 };
 function knownArguments(config4) {
   return function(ctx) {
-    const nativeValidator = graphql25.KnownArgumentNamesRule(ctx);
+    const nativeValidator = graphql26.KnownArgumentNamesRule(ctx);
     return {
       ...nativeValidator,
       Directive(directiveNode) {
@@ -72994,7 +72987,7 @@ function validateFragmentArguments(config4, 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 graphql26.GraphQLError("values in @arguments must be an object")
             );
             return;
           }
@@ -73004,13 +72997,13 @@ function validateFragmentArguments(config4, filepath, fragments) {
           );
           if (!typeArg) {
             ctx.reportError(
-              new graphql25.GraphQLError("missing type field for @arguments directive")
+              new graphql26.GraphQLError("missing type field for @arguments directive")
             );
             return;
           }
-          if (typeArg.value.kind !== graphql25.Kind.STRING) {
+          if (typeArg.value.kind !== graphql26.Kind.STRING) {
             ctx.reportError(
-              new graphql25.GraphQLError("type field to @arguments must be a string")
+              new graphql26.GraphQLError("type field to @arguments must be a string")
             );
             return;
           }
@@ -73023,7 +73016,7 @@ function validateFragmentArguments(config4, filepath, fragments) {
           );
           if (typeArg.value.value !== defaultValueType) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql26.GraphQLError(
                 `Invalid default value provided for ${arg.name.value}. Expected ${typeArg.value.value}, found ${defaultValueType}`
               )
             );
@@ -73041,7 +73034,7 @@ function validateFragmentArguments(config4, filepath, fragments) {
           try {
             args = fragmentArguments(config4, filepath, fragments[fragmentName]);
           } catch (e2) {
-            ctx.reportError(new graphql25.GraphQLError(e2.message));
+            ctx.reportError(new graphql26.GraphQLError(e2.message));
             return;
           }
           fragmentArguments2[fragmentName] = args;
@@ -73064,7 +73057,7 @@ function validateFragmentArguments(config4, filepath, fragments) {
         );
         if (missing.length > 0) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               "The following arguments are missing from this fragment: " + JSON.stringify(missing)
             )
           );
@@ -73075,7 +73068,7 @@ function validateFragmentArguments(config4, filepath, fragments) {
         );
         if (unknown.length > 0) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown arguments: " + JSON.stringify(unknown)
             )
           );
@@ -73087,7 +73080,7 @@ function validateFragmentArguments(config4, 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 === graphql26.Kind.VARIABLE || applied.value.kind === graphql26.Kind.LIST || applied.value.kind === graphql26.Kind.OBJECT) {
               continue;
             }
             const appliedType = applied.value.kind.substring(
@@ -73096,7 +73089,7 @@ function validateFragmentArguments(config4, filepath, fragments) {
             );
             if (appliedType !== target) {
               ctx.reportError(
-                new graphql25.GraphQLError(
+                new graphql26.GraphQLError(
                   `Invalid argument type. Expected ${target}, found ${appliedType}`
                 )
               );
@@ -73117,7 +73110,7 @@ function paginateArgs(config4, filepath) {
         }
         if (alreadyPaginated) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `@${config4.paginateDirective} can only appear in a document once.`
             )
           );
@@ -73132,7 +73125,7 @@ function paginateArgs(config4, filepath) {
         const hasRequiredArgs = definitionArgs.find((arg) => arg.required);
         if (hasRequiredArgs) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               "@paginate cannot appear on a document with required args"
             )
           );
@@ -73164,14 +73157,14 @@ function paginateArgs(config4, filepath) {
           const backwards = appliedArgs.has("last");
           if (!forward && !backwards) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql26.GraphQLError(
                 "A field with cursor-based pagination must have a first or last argument"
               )
             );
           }
           if (forward && backwards) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql26.GraphQLError(
                 `A field with cursor pagination cannot go forwards an backwards simultaneously`
               )
             );
@@ -73185,7 +73178,7 @@ function paginateArgs(config4, filepath) {
           );
           if (!appliedLimitArg) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql26.GraphQLError(
                 "A field with offset-based pagination must have a limit argument"
               )
             );
@@ -73201,20 +73194,20 @@ function noUnusedFragmentArguments(config4) {
     const args = /* @__PURE__ */ new Set();
     return {
       enter(node) {
-        if (node.kind === graphql25.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql26.Kind.FRAGMENT_DEFINITION) {
           const definitionArguments = node.directives?.filter((directive) => directive.name.value === config4.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 === graphql26.Kind.VARIABLE) {
           args.delete(node.name.value);
         }
       },
       leave(node) {
-        if (node.kind === graphql25.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql26.Kind.FRAGMENT_DEFINITION) {
           if (args.size > 0) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql26.GraphQLError(
                 "Encountered unused fragment arguments: " + [...args].join(",")
               )
             );
@@ -73250,7 +73243,7 @@ function nodeDirectives(config4, directives) {
         if (definition.kind === "OperationDefinition") {
           if (definition.operation !== "query") {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql26.GraphQLError(
                 `@${node.name.value} must fall on a fragment or query document`
               )
             );
@@ -73262,7 +73255,7 @@ function nodeDirectives(config4, directives) {
         }
         if (!possibleNodes.includes(definitionType)) {
           ctx.reportError(
-            new graphql25.GraphQLError(paginateOnNonNodeMessage(config4, node.name.value))
+            new graphql26.GraphQLError(paginateOnNonNodeMessage(config4, node.name.value))
           );
         }
       }
@@ -73281,7 +73274,7 @@ function checkMutationOperation(config4) {
         );
         if (append && prepend) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config4.listPrependDirective} and @${config4.listAppendDirective} at the same time`
             )
           );
@@ -73295,7 +73288,7 @@ function checkMutationOperation(config4) {
         );
         if (parentId && allLists) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config4.listParentDirective} and @${config4.listAllListsDirective} at the same time`
             )
           );
@@ -73317,7 +73310,7 @@ function checkMaskDirective(config4) {
         );
         if (maskEnableDirective && maskDisableDirective) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config4.maskEnableDirective} and @${config4.maskDisableDirective} at the same time`
             )
           );
@@ -73333,7 +73326,7 @@ function getAndVerifyNodeInterface(config4) {
   if (!nodeInterface) {
     return null;
   }
-  if (!graphql25.isInterfaceType(nodeInterface)) {
+  if (!graphql26.isInterfaceType(nodeInterface)) {
     displayInvalidNodeFieldMessage(config4.logLevel);
     return null;
   }
@@ -73431,11 +73424,11 @@ async function uniqueDocumentNames(config4, docs) {
 }
 
 // src/codegen/validators/noIDAlias.ts
-var graphql26 = __toESM(require_graphql2(), 1);
+var graphql27 = __toESM(require_graphql2(), 1);
 async function noIDAlias(config4, docs) {
   const errors = [];
   for (const { filename, document } of docs) {
-    graphql26.visit(document, {
+    graphql27.visit(document, {
       Field(node, _, __, ___, ancestors) {
         const fieldType = parentTypeFromAncestors(config4.schema, filename, ancestors).name;
         if (config4.keyFieldsForType(fieldType).includes(node.alias?.value || "")) {
@@ -73633,12 +73626,12 @@ async function processJSFile(config4, contents) {
   return documents;
 }
 async function processGraphQLDocument(config4, filepath, document) {
-  const parsedDoc = graphql27.parse(document);
+  const parsedDoc = graphql28.parse(document);
   const operations = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql27.Kind.OPERATION_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql28.Kind.OPERATION_DEFINITION
   );
   const fragments = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql27.Kind.FRAGMENT_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql28.Kind.FRAGMENT_DEFINITION
   );
   if (operations.length > 1) {
     throw new HoudiniError({