houdini 0.18.2 → 0.18.3

package/build/cmd-cjs/index.js

@@ -2282,7 +2282,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",
@@ -2327,7 +2327,7 @@ var require_kinds = __commonJS({
       ENUM_TYPE_EXTENSION: "EnumTypeExtension",
       INPUT_OBJECT_TYPE_EXTENSION: "InputObjectTypeExtension"
     });
-    exports.Kind = Kind29;
+    exports.Kind = Kind30;
   }
 });
 
@@ -11507,7 +11507,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();
@@ -11517,7 +11517,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(
@@ -72389,10 +72389,10 @@ async function find_graphql(config2, parsedScript, walker) {
 }
 
 // src/codegen/index.ts
-var graphql27 = __toESM(require_graphql2(), 1);
+var graphql28 = __toESM(require_graphql2(), 1);
 
 // 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
@@ -72996,7 +72996,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 config = {
@@ -73036,10 +73036,24 @@ function logYellow(str) {
 }
 
 // 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 = (config2, type) => {
+  return config2.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(config2, documents) {
   const newDocs = [];
   for (const doc of documents) {
@@ -73072,7 +73086,7 @@ async function paginate(config2, 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 === config2.paginateDirective
@@ -73099,7 +73113,7 @@ async function paginate(config2, 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,
@@ -73120,7 +73134,7 @@ async function paginate(config2, 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({
@@ -73174,9 +73188,9 @@ async function paginate(config2, documents) {
               directives: [
                 ...node.directives || [],
                 {
-                  kind: graphql9.Kind.DIRECTIVE,
+                  kind: graphql10.Kind.DIRECTIVE,
                   name: {
-                    kind: graphql9.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: config2.argumentsDirective
                   }
                 }
@@ -73239,16 +73253,16 @@ async function paginate(config2, 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: config2.withDirective
               },
               ["arguments"]: paginationArgs.map(
@@ -73276,29 +73290,29 @@ async function paginate(config2, documents) {
       });
       const typeConfig = config2.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
                   }
                 },
@@ -73310,12 +73324,12 @@ async function paginate(config2, 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
                     }
                   }
@@ -73323,42 +73337,42 @@ async function paginate(config2, 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
                         }
                       })),
@@ -73420,15 +73434,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
       }
     }
@@ -73436,18 +73450,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
       }
     },
@@ -73459,9 +73473,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)
@@ -73469,16 +73483,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
         }
       }
@@ -73486,8 +73500,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()
@@ -73498,34 +73512,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"
                 }
               }
@@ -73536,39 +73550,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"
           }
         }
@@ -73582,15 +73596,15 @@ async function addListFragments(config2, 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 ([config2.listDirective, config2.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
             ),
@@ -73642,7 +73656,7 @@ async function addListFragments(config2, documents) {
                 {
                   kind: "Argument",
                   name: {
-                    kind: graphql10.Kind.NAME,
+                    kind: graphql11.Kind.NAME,
                     value: "connection"
                   },
                   value: {
@@ -73689,10 +73703,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 graphql10.GraphQLObjectType)) {
+        if (!(type instanceof graphql11.GraphQLObjectType)) {
+          return "";
+        }
+        if (config2.keyFieldsForType(type.name).length !== 1) {
           return "";
         }
         return type.name;
@@ -73703,7 +73720,7 @@ async function addListFragments(config2, documents) {
     return;
   }
   const generatedDoc = {
-    kind: graphql10.Kind.DOCUMENT,
+    kind: graphql11.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
       ([name2, { selection: selection2, type }]) => {
         const schemaType = config2.schema.getType(type.name);
@@ -73711,35 +73728,29 @@ async function addListFragments(config2, 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" && config2.keyFieldsForType(type.name).includes(field.name.value)
         )) {
           fragmentSelection.selections = [
             ...fragmentSelection.selections,
-            {
-              kind: graphql10.Kind.FIELD,
-              name: {
-                kind: graphql10.Kind.NAME,
-                value: "id"
-              }
-            }
+            ...objectIdentificationSelection(config2, type)
           ];
         }
         return [
           {
             name: {
               value: config2.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
               }
             }
@@ -73747,52 +73758,32 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.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: config2.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(config2, type)]
             },
             typeCondition: {
-              kind: graphql10.Kind.NAMED_TYPE,
+              kind: graphql11.Kind.NAMED_TYPE,
               name: {
-                kind: graphql10.Kind.NAME,
+                kind: graphql11.Kind.NAME,
                 value: type.name
               }
             }
@@ -73800,15 +73791,15 @@ async function addListFragments(config2, 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: config2.listDeleteDirective(typeName)
         },
         locations: [
           {
-            kind: graphql10.Kind.NAME,
+            kind: graphql11.Kind.NAME,
             value: "FIELD"
           }
         ],
@@ -73816,8 +73807,8 @@ async function addListFragments(config2, documents) {
       }))
     )
   };
-  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql10.print).join("\n\n");
-  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql10.print).join("\n\n");
+  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql11.print).join("\n\n");
+  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql11.print).join("\n\n");
   documents.push({
     name: "generated::lists",
     kind: "HoudiniFragment" /* Fragment */,
@@ -73902,11 +73893,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 graphql11 = __toESM(require_graphql2(), 1);
+var graphql12 = __toESM(require_graphql2(), 1);
 function fieldKey(config2, 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 === config2.paginateDirective
   );
@@ -73999,8 +73990,8 @@ function selection({
         const typeConditionName = field.typeCondition.name.value;
         const typeCondition = config2.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 = config2.schema.getPossibleTypes(parentType).map((type) => type.name);
           for (const possible of config2.schema.getPossibleTypes(typeCondition)) {
             if (possibleParentTypes.includes(possible.name)) {
@@ -74048,7 +74039,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);
@@ -74113,7 +74104,7 @@ function selection({
           {}
         );
       }
-      if (graphql12.isInterfaceType(fieldType) || graphql12.isUnionType(fieldType)) {
+      if (graphql13.isInterfaceType(fieldType) || graphql13.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
       object.fields = {
@@ -74170,7 +74161,7 @@ function artifactGenerator(stats) {
   return async function(config2, docs) {
     const filterTypes = {};
     for (const doc of docs) {
-      graphql13.visit(doc.document, {
+      graphql14.visit(doc.document, {
         Directive(node, _, __, ___, ancestors) {
           if (node.name.value !== config2.listDirective) {
             return;
@@ -74229,7 +74220,7 @@ function artifactGenerator(stats) {
             return;
           }
           const usedVariableNames = /* @__PURE__ */ new Set();
-          let documentWithoutInternalDirectives = graphql13.visit(document, {
+          let documentWithoutInternalDirectives = graphql14.visit(document, {
             Directive(node) {
               if (config2.isInternalDirective(node)) {
                 return null;
@@ -74242,7 +74233,7 @@ function artifactGenerator(stats) {
               }
             }
           });
-          let documentWithoutExtraVariables = graphql13.visit(
+          let documentWithoutExtraVariables = graphql14.visit(
             documentWithoutInternalDirectives,
             {
               VariableDefinition(variableDefinitionNode) {
@@ -74253,13 +74244,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;
@@ -74446,15 +74437,15 @@ async function generatePluginRuntime(config2, 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) {
@@ -74488,7 +74479,7 @@ function scalarPropertyValue(config2, missingScalars, target) {
       return AST6.tsStringKeyword();
     }
     default: {
-      if (graphql14.isNonNullType(target) && "ofType" in target) {
+      if (graphql15.isNonNullType(target) && "ofType" in target) {
         return scalarPropertyValue(
           config2,
           missingScalars,
@@ -74509,7 +74500,7 @@ var AST7 = recast7.types.builders;
 function tsTypeReference(config2, missingScalars, definition) {
   const { type, wrappers } = unwrapType(config2, definition.type);
   let result;
-  if (graphql15.isScalarType(type)) {
+  if (graphql16.isScalarType(type)) {
     result = scalarPropertyValue(config2, missingScalars, type);
   } else {
     result = AST7.tsTypeReference(AST7.identifier(type.name));
@@ -74530,17 +74521,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 (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: config2,
       body,
@@ -74557,7 +74548,7 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
       AST8.tsPropertySignature(
         AST8.identifier(field.name),
         AST8.tsTypeAnnotation(tsTypeReference(config2, missingScalars, field)),
-        graphql16.isNullableType(field.type)
+        graphql17.isNullableType(field.type)
       )
     );
   }
@@ -74565,7 +74556,7 @@ function addReferencedInputTypes(config2, 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";
@@ -74584,9 +74575,9 @@ function inlineType({
 }) {
   const { type, wrappers } = unwrapType(config2, rootType);
   let result;
-  if (graphql17.isScalarType(type)) {
+  if (graphql18.isScalarType(type)) {
     result = scalarPropertyValue(config2, missingScalars, type);
-  } else if (graphql17.isEnumType(type)) {
+  } else if (graphql18.isEnumType(type)) {
     if (!visitedTypes.has(type.name)) {
       ensureImports({
         config: config2,
@@ -74604,11 +74595,11 @@ function inlineType({
     for (const selection2 of selections) {
       if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
         const fragmentType = config2.schema.getType(selection2.typeCondition.name.value);
-        if (!graphql17.isInterfaceType(type) && !graphql17.isUnionType(type)) {
+        if (!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] = [];
           }
@@ -74728,7 +74719,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"
         );
@@ -74795,7 +74786,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();
@@ -74807,7 +74798,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,
@@ -75127,7 +75118,7 @@ async function generateFragmentTypeDefs(config2, 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(config2, docs) {
   if (typeof config2.persistedQueryPath !== "string" || config2.persistedQueryPath.length === 0)
     return;
@@ -75139,8 +75130,8 @@ async function persistOutputGenerator(config2, docs) {
     if (!generateArtifact) {
       return acc;
     }
-    let rawString = graphql18.print(
-      graphql18.visit(document, {
+    let rawString = graphql19.print(
+      graphql19.visit(document, {
         Directive(node) {
           if (config2.isInternalDirective(node)) {
             return null;
@@ -75149,7 +75140,7 @@ async function persistOutputGenerator(config2, 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;
@@ -75162,11 +75153,11 @@ async function persistOutputGenerator(config2, 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(config2) {
-  const enums = graphql19.parse(graphql19.printSchema(config2.schema)).definitions.filter(
+  const enums = graphql20.parse(graphql20.printSchema(config2.schema)).definitions.filter(
     (definition) => definition.kind === "EnumTypeDefinition"
   ).filter((def) => !config2.isInternalEnum(def));
   const runtimeDefinitions = recast11.print(
@@ -75339,7 +75330,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(config2, documents) {
   const internalSchema = `
 enum CachePolicy {
@@ -75417,19 +75408,19 @@ directive @${config2.maskEnableDirective} on FRAGMENT_SPREAD
 """
 directive @${config2.maskDisableDirective} on FRAGMENT_SPREAD
 `;
-  let currentSchema = graphql21.printSchema(config2.schema);
+  let currentSchema = graphql22.printSchema(config2.schema);
   if (!currentSchema.includes(`directive @${config2.listDirective}`)) {
     currentSchema += internalSchema;
   }
   config2.newSchema += internalSchema;
-  config2.schema = graphql21.buildSchema(currentSchema);
+  config2.schema = graphql22.buildSchema(currentSchema);
 }
 
 // src/codegen/transforms/typename.ts
-var graphql22 = __toESM(require_graphql2(), 1);
+var graphql23 = __toESM(require_graphql2(), 1);
 async function addTypename(config2, 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;
@@ -75441,7 +75432,7 @@ async function addTypename(config2, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
-        if (graphql22.isInterfaceType(fieldType) || graphql22.isUnionType(fieldType)) {
+        if (graphql23.isInterfaceType(fieldType) || graphql23.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -75449,9 +75440,9 @@ async function addTypename(config2, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql22.Kind.FIELD,
+                  kind: graphql23.Kind.FIELD,
                   name: {
-                    kind: graphql22.Kind.NAME,
+                    kind: graphql23.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -75465,10 +75456,10 @@ async function addTypename(config2, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql23 = __toESM(require_graphql2(), 1);
+var graphql24 = __toESM(require_graphql2(), 1);
 async function addID(config2, 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;
@@ -75481,7 +75472,7 @@ async function addID(config2, documents) {
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
         if (node.selectionSet?.selections.length > 0) {
-          if (!graphql23.isObjectType(fieldType) && !graphql23.isInterfaceType(fieldType)) {
+          if (!graphql24.isObjectType(fieldType) && !graphql24.isInterfaceType(fieldType)) {
             return;
           }
           const keyFields = config2.keyFieldsForType(fieldType.name);
@@ -75496,9 +75487,9 @@ async function addID(config2, documents) {
               continue;
             }
             selections.push({
-              kind: graphql23.Kind.FIELD,
+              kind: graphql24.Kind.FIELD,
               name: {
-                kind: graphql23.Kind.NAME,
+                kind: graphql24.Kind.NAME,
                 value: keyField
               }
             });
@@ -75517,8 +75508,8 @@ async function addID(config2, 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(config2, documents) {
   const fragments = collectFragments(config2, documents);
   const generatedFragments = {};
@@ -75541,7 +75532,7 @@ async function fragmentVariables(config2, documents) {
     });
   }
   const doc = {
-    kind: graphql24.Kind.DOCUMENT,
+    kind: graphql25.Kind.DOCUMENT,
     definitions: Object.values(generatedFragments)
   };
   documents.push({
@@ -75577,7 +75568,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(config2, filepath, node, scope);
@@ -75665,7 +75656,7 @@ function inlineFragmentArgs({
   });
   if (newName) {
     result.name = {
-      kind: graphql24.Kind.NAME,
+      kind: graphql25.Kind.NAME,
       value: newName
     };
   }
@@ -75777,7 +75768,7 @@ function operationScope(operation) {
 }
 
 // src/codegen/validators/typeCheck.ts
-var graphql25 = __toESM(require_graphql2(), 1);
+var graphql26 = __toESM(require_graphql2(), 1);
 async function typeCheck(config2, docs) {
   const errors = [];
   const freeLists = [];
@@ -75785,11 +75776,11 @@ async function typeCheck(config2, docs) {
   const listTypes = [];
   const fragments = {};
   for (const { document: parsed, filename } of docs) {
-    graphql25.visit(parsed, {
-      [graphql25.Kind.FRAGMENT_DEFINITION](definition) {
+    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 (![config2.listDirective, config2.paginateDirective].includes(directive.name.value)) {
           return;
         }
@@ -75835,14 +75826,14 @@ async function typeCheck(config2, 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;
@@ -75898,7 +75889,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(
@@ -75908,10 +75899,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 (graphql25.isUnionType(type)) {
+        if (graphql26.isUnionType(type)) {
           targetTypes = config2.schema.getPossibleTypes(type);
-        } else if (graphql25.isInterfaceType(type)) {
+        } else if (graphql26.isInterfaceType(type)) {
           try {
             for (const key of config2.keyFieldsForType(type.name)) {
               if (!type.getFields()[key]) {
@@ -75925,23 +75925,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;
           }
         }
@@ -75956,13 +75949,13 @@ async function typeCheck(config2, 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({
@@ -75981,7 +75974,7 @@ async function typeCheck(config2, docs) {
     noUnusedFragmentArguments(config2)
   );
   for (const { filename, document: parsed } of docs) {
-    for (const error of graphql25.validate(config2.schema, parsed, rules(filename))) {
+    for (const error of graphql26.validate(config2.schema, parsed, rules(filename))) {
       errors.push(
         new HoudiniError({
           filepath: filename,
@@ -76007,7 +76000,7 @@ var validateLists = ({
       if (!config2.isListFragment(node.name.value)) {
         if (!fragments[node.name.value]) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown fragment: " + node.name.value
             )
           );
@@ -76017,7 +76010,7 @@ var validateLists = ({
       const listName = config2.listNameFromFragment(node.name.value);
       if (!lists.includes(listName)) {
         ctx.reportError(
-          new graphql25.GraphQLError(
+          new graphql26.GraphQLError(
             "Encountered fragment referencing unknown list: " + listName
           )
         );
@@ -76042,7 +76035,7 @@ var validateLists = ({
         );
         if (parentArg) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `@${config2.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
             )
           );
@@ -76058,7 +76051,7 @@ var validateLists = ({
         return;
       }
       ctx.reportError(
-        new graphql25.GraphQLError(
+        new graphql26.GraphQLError(
           `For this list fragment, you need to add or @${config2.listParentDirective} or @${config2.listAllListsDirective} directive to specify the behavior`
         )
       );
@@ -76068,7 +76061,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."
           )
         );
@@ -76077,7 +76070,7 @@ var validateLists = ({
       if (!config2.isInternalDirective(node)) {
         if (!config2.schema.getDirective(directiveName)) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown directive: " + directiveName
             )
           );
@@ -76086,7 +76079,7 @@ var validateLists = ({
       }
       if (config2.isListOperationDirective(directiveName) && !listTypes.includes(config2.listNameFromDirective(directiveName))) {
         ctx.reportError(
-          new graphql25.GraphQLError(
+          new graphql26.GraphQLError(
             "Encountered directive referencing unknown list: " + directiveName
           )
         );
@@ -76097,7 +76090,7 @@ var validateLists = ({
 };
 function knownArguments(config2) {
   return function(ctx) {
-    const nativeValidator = graphql25.KnownArgumentNamesRule(ctx);
+    const nativeValidator = graphql26.KnownArgumentNamesRule(ctx);
     return {
       ...nativeValidator,
       Directive(directiveNode) {
@@ -76130,7 +76123,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         for (const arg of node.arguments || []) {
           if (arg.value.kind !== "ObjectValue") {
             ctx.reportError(
-              new graphql25.GraphQLError("values in @arguments must be an object")
+              new graphql26.GraphQLError("values in @arguments must be an object")
             );
             return;
           }
@@ -76140,13 +76133,13 @@ function validateFragmentArguments(config2, 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;
           }
@@ -76159,7 +76152,7 @@ function validateFragmentArguments(config2, 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}`
               )
             );
@@ -76177,7 +76170,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           try {
             args = fragmentArguments(config2, filepath, fragments[fragmentName]);
           } catch (e2) {
-            ctx.reportError(new graphql25.GraphQLError(e2.message));
+            ctx.reportError(new graphql26.GraphQLError(e2.message));
             return;
           }
           fragmentArguments2[fragmentName] = args;
@@ -76200,7 +76193,7 @@ function validateFragmentArguments(config2, 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)
             )
           );
@@ -76211,7 +76204,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (unknown.length > 0) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown arguments: " + JSON.stringify(unknown)
             )
           );
@@ -76223,7 +76216,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             ]
           );
           for (const [applied, target] of zipped) {
-            if (applied.value.kind === graphql25.Kind.VARIABLE || applied.value.kind === graphql25.Kind.LIST || applied.value.kind === graphql25.Kind.OBJECT) {
+            if (applied.value.kind === graphql26.Kind.VARIABLE || applied.value.kind === graphql26.Kind.LIST || applied.value.kind === graphql26.Kind.OBJECT) {
               continue;
             }
             const appliedType = applied.value.kind.substring(
@@ -76232,7 +76225,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             );
             if (appliedType !== target) {
               ctx.reportError(
-                new graphql25.GraphQLError(
+                new graphql26.GraphQLError(
                   `Invalid argument type. Expected ${target}, found ${appliedType}`
                 )
               );
@@ -76253,7 +76246,7 @@ function paginateArgs(config2, filepath) {
         }
         if (alreadyPaginated) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `@${config2.paginateDirective} can only appear in a document once.`
             )
           );
@@ -76268,7 +76261,7 @@ function paginateArgs(config2, 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"
             )
           );
@@ -76300,14 +76293,14 @@ function paginateArgs(config2, 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`
               )
             );
@@ -76321,7 +76314,7 @@ function paginateArgs(config2, filepath) {
           );
           if (!appliedLimitArg) {
             ctx.reportError(
-              new graphql25.GraphQLError(
+              new graphql26.GraphQLError(
                 "A field with offset-based pagination must have a limit argument"
               )
             );
@@ -76337,20 +76330,20 @@ function noUnusedFragmentArguments(config2) {
     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 === config2.argumentsDirective).flatMap((directive) => directive.arguments);
           for (const arg of definitionArguments?.map((arg2) => arg2?.name.value) || []) {
             args.add(arg);
           }
-        } else if (node.kind === graphql25.Kind.VARIABLE) {
+        } else if (node.kind === 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(",")
               )
             );
@@ -76386,7 +76379,7 @@ function nodeDirectives(config2, 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`
               )
             );
@@ -76398,7 +76391,7 @@ function nodeDirectives(config2, directives) {
         }
         if (!possibleNodes.includes(definitionType)) {
           ctx.reportError(
-            new graphql25.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
+            new graphql26.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
           );
         }
       }
@@ -76417,7 +76410,7 @@ function checkMutationOperation(config2) {
         );
         if (append && prepend) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config2.listPrependDirective} and @${config2.listAppendDirective} at the same time`
             )
           );
@@ -76431,7 +76424,7 @@ function checkMutationOperation(config2) {
         );
         if (parentId && allLists) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config2.listParentDirective} and @${config2.listAllListsDirective} at the same time`
             )
           );
@@ -76453,7 +76446,7 @@ function checkMaskDirective(config2) {
         );
         if (maskEnableDirective && maskDisableDirective) {
           ctx.reportError(
-            new graphql25.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config2.maskEnableDirective} and @${config2.maskDisableDirective} at the same time`
             )
           );
@@ -76469,7 +76462,7 @@ function getAndVerifyNodeInterface(config2) {
   if (!nodeInterface) {
     return null;
   }
-  if (!graphql25.isInterfaceType(nodeInterface)) {
+  if (!graphql26.isInterfaceType(nodeInterface)) {
     displayInvalidNodeFieldMessage(config2.logLevel);
     return null;
   }
@@ -76567,11 +76560,11 @@ async function uniqueDocumentNames(config2, docs) {
 }
 
 // src/codegen/validators/noIDAlias.ts
-var graphql26 = __toESM(require_graphql2(), 1);
+var graphql27 = __toESM(require_graphql2(), 1);
 async function noIDAlias(config2, docs) {
   const errors = [];
   for (const { filename, document } of docs) {
-    graphql26.visit(document, {
+    graphql27.visit(document, {
       Field(node, _, __, ___, ancestors) {
         const fieldType = parentTypeFromAncestors(config2.schema, filename, ancestors).name;
         if (config2.keyFieldsForType(fieldType).includes(node.alias?.value || "")) {
@@ -76769,12 +76762,12 @@ async function processJSFile(config2, contents) {
   return documents;
 }
 async function processGraphQLDocument(config2, 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({
@@ -77313,8 +77306,8 @@ async function updatePackageJSON(targetPath) {
   }
   packageJSON.devDependencies = {
     ...packageJSON.devDependencies,
-    houdini: "^0.18.2",
-    "houdini-svelte": "^0.18.2",
+    houdini: "^0.18.3",
+    "houdini-svelte": "^0.18.3",
     graphql: "^15.8.0"
   };
   await fs_exports.writeFile(packagePath, JSON.stringify(packageJSON, null, 4));