houdini 0.17.13 → 0.18.0

package/build/test-cjs/index.js

@@ -3345,7 +3345,7 @@ var require_definition = __commonJS({
     exports.assertObjectType = assertObjectType;
     exports.isInterfaceType = isInterfaceType6;
     exports.assertInterfaceType = assertInterfaceType;
-    exports.isUnionType = isUnionType6;
+    exports.isUnionType = isUnionType7;
     exports.assertUnionType = assertUnionType;
     exports.isEnumType = isEnumType4;
     exports.assertEnumType = assertEnumType;
@@ -3363,7 +3363,7 @@ var require_definition = __commonJS({
     exports.assertLeafType = assertLeafType;
     exports.isCompositeType = isCompositeType;
     exports.assertCompositeType = assertCompositeType;
-    exports.isAbstractType = isAbstractType;
+    exports.isAbstractType = isAbstractType2;
     exports.assertAbstractType = assertAbstractType;
     exports.GraphQLList = GraphQLList2;
     exports.GraphQLNonNull = GraphQLNonNull2;
@@ -3418,7 +3418,7 @@ var require_definition = __commonJS({
       return Constructor;
     }
     function isType(type) {
-      return isScalarType6(type) || isObjectType2(type) || isInterfaceType6(type) || isUnionType6(type) || isEnumType4(type) || isInputObjectType(type) || isListType3(type) || isNonNullType6(type);
+      return isScalarType6(type) || isObjectType2(type) || isInterfaceType6(type) || isUnionType7(type) || isEnumType4(type) || isInputObjectType(type) || isListType3(type) || isNonNullType6(type);
     }
     function assertType(type) {
       if (!isType(type)) {
@@ -3453,11 +3453,11 @@ var require_definition = __commonJS({
       }
       return type;
     }
-    function isUnionType6(type) {
+    function isUnionType7(type) {
       return (0, _instanceOf.default)(type, GraphQLUnionType);
     }
     function assertUnionType(type) {
-      if (!isUnionType6(type)) {
+      if (!isUnionType7(type)) {
         throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Union type."));
       }
       return type;
@@ -3508,7 +3508,7 @@ var require_definition = __commonJS({
       return type;
     }
     function isOutputType(type) {
-      return isScalarType6(type) || isObjectType2(type) || isInterfaceType6(type) || isUnionType6(type) || isEnumType4(type) || isWrappingType(type) && isOutputType(type.ofType);
+      return isScalarType6(type) || isObjectType2(type) || isInterfaceType6(type) || isUnionType7(type) || isEnumType4(type) || isWrappingType(type) && isOutputType(type.ofType);
     }
     function assertOutputType(type) {
       if (!isOutputType(type)) {
@@ -3526,7 +3526,7 @@ var require_definition = __commonJS({
       return type;
     }
     function isCompositeType(type) {
-      return isObjectType2(type) || isInterfaceType6(type) || isUnionType6(type);
+      return isObjectType2(type) || isInterfaceType6(type) || isUnionType7(type);
     }
     function assertCompositeType(type) {
       if (!isCompositeType(type)) {
@@ -3534,11 +3534,11 @@ var require_definition = __commonJS({
       }
       return type;
     }
-    function isAbstractType(type) {
-      return isInterfaceType6(type) || isUnionType6(type);
+    function isAbstractType2(type) {
+      return isInterfaceType6(type) || isUnionType7(type);
     }
     function assertAbstractType(type) {
-      if (!isAbstractType(type)) {
+      if (!isAbstractType2(type)) {
         throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL abstract type."));
       }
       return type;
@@ -3605,7 +3605,7 @@ var require_definition = __commonJS({
       }
     }
     function isNamedType(type) {
-      return isScalarType6(type) || isObjectType2(type) || isInterfaceType6(type) || isUnionType6(type) || isEnumType4(type) || isInputObjectType(type);
+      return isScalarType6(type) || isObjectType2(type) || isInterfaceType6(type) || isUnionType7(type) || isEnumType4(type) || isInputObjectType(type);
     }
     function assertNamedType(type) {
       if (!isNamedType(type)) {
@@ -53467,6 +53467,20 @@ function deepEquals(objA, objB, map = /* @__PURE__ */ new WeakMap()) {
   return true;
 }
 
+// src/runtime/lib/selection.ts
+function getFieldsForType(selection2, __typename) {
+  let targetSelection = selection2.fields || {};
+  if (selection2.abstractFields && __typename) {
+    const mappedType = selection2.abstractFields.typeMap[__typename];
+    if (mappedType) {
+      targetSelection = selection2.abstractFields.fields[mappedType];
+    } else if (selection2.abstractFields.fields[__typename]) {
+      targetSelection = selection2.abstractFields.fields[__typename];
+    }
+  }
+  return targetSelection;
+}
+
 // src/runtime/cache/gc.ts
 var GarbageCollector = class {
   cache;
@@ -53689,23 +53703,32 @@ var List = class {
     let insertData = data;
     if (this.connection) {
       insertSelection = {
-        newEntry: {
-          keyRaw: this.key,
-          type: "Connection",
-          fields: {
-            edges: {
-              keyRaw: "edges",
-              type: "ConnectionEdge",
-              update: where === "first" ? "prepend" : "append",
+        fields: {
+          newEntry: {
+            keyRaw: this.key,
+            type: "Connection",
+            selection: {
               fields: {
-                node: {
-                  type: listType,
-                  keyRaw: "node",
-                  fields: {
-                    ...selection2,
-                    __typename: {
-                      keyRaw: "__typename",
-                      type: "String"
+                edges: {
+                  keyRaw: "edges",
+                  type: "ConnectionEdge",
+                  update: where === "first" ? "prepend" : "append",
+                  selection: {
+                    fields: {
+                      node: {
+                        type: listType,
+                        keyRaw: "node",
+                        selection: {
+                          ...selection2,
+                          fields: {
+                            ...selection2.fields,
+                            __typename: {
+                              keyRaw: "__typename",
+                              type: "String"
+                            }
+                          }
+                        }
+                      }
                     }
                   }
                 }
@@ -53721,15 +53744,20 @@ var List = class {
       };
     } else {
       insertSelection = {
-        newEntries: {
-          keyRaw: this.key,
-          type: listType,
-          update: where === "first" ? "prepend" : "append",
-          fields: {
-            ...selection2,
-            __typename: {
-              keyRaw: "__typename",
-              type: "String"
+        fields: {
+          newEntries: {
+            keyRaw: this.key,
+            type: listType,
+            update: where === "first" ? "prepend" : "append",
+            selection: {
+              ...selection2,
+              fields: {
+                ...selection2.fields,
+                __typename: {
+                  keyRaw: "__typename",
+                  type: "String"
+                }
+              }
             }
           }
         }
@@ -53789,7 +53817,7 @@ var List = class {
     const subscribers = this.cache._internal_unstable.subscriptions.get(this.recordID, this.key);
     this.cache._internal_unstable.subscriptions.remove(
       targetID,
-      this.connection ? this.selection.edges.fields : this.selection,
+      this.connection ? this.selection.fields.edges.selection : this.selection,
       subscribers,
       variables
     );
@@ -54278,18 +54306,20 @@ var InMemorySubscriptions = class {
     variables,
     parentType
   }) {
-    for (const fieldSelection of Object.values(selection2)) {
-      const { keyRaw, fields, type } = fieldSelection;
+    const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
+    let targetSelection = getFieldsForType(selection2, __typename);
+    for (const fieldSelection of Object.values(targetSelection || {})) {
+      const { keyRaw, selection: innerSelection, type } = fieldSelection;
       const key = evaluateKey(keyRaw, variables);
       this.addFieldSubscription({
         id: parent,
         key,
-        selection: fieldSelection,
+        field: fieldSelection,
         spec,
         parentType: parentType || spec.rootType,
         variables
       });
-      if (fields) {
+      if (innerSelection) {
         const { value: linkedRecord } = this.cache._internal_unstable.storage.get(
           parent,
           key
@@ -54302,7 +54332,7 @@ var InMemorySubscriptions = class {
           this.add({
             parent: child,
             spec,
-            selection: fields,
+            selection: innerSelection,
             variables,
             parentType: type
           });
@@ -54313,7 +54343,7 @@ var InMemorySubscriptions = class {
   addFieldSubscription({
     id,
     key,
-    selection: selection2,
+    field,
     spec,
     parentType,
     variables
@@ -54340,8 +54370,8 @@ var InMemorySubscriptions = class {
     const counts = this.referenceCounts[id][key];
     counts.set(spec.set, (counts.get(spec.set) || 0) + 1);
     this.cache._internal_unstable.lifetimes.resetLifetime(id, key);
-    const { fields, list, filters } = selection2;
-    if (fields && list) {
+    const { selection: selection2, list, filters } = field;
+    if (selection2 && list) {
       this.cache._internal_unstable.lists.add({
         name: list.name,
         connection: list.connection,
@@ -54349,7 +54379,7 @@ var InMemorySubscriptions = class {
         recordType: this.cache._internal_unstable.storage.get(id, "__typename")?.value || parentType,
         listType: list.type,
         key,
-        selection: fields,
+        selection: selection2,
         filters: Object.entries(filters || {}).reduce((acc, [key2, { kind, value }]) => {
           return {
             ...acc,
@@ -54366,20 +54396,21 @@ var InMemorySubscriptions = class {
     subscribers,
     parentType
   }) {
-    for (const fieldSelection of Object.values(selection2)) {
-      const { type: linkedType, keyRaw, fields } = fieldSelection;
+    let targetSelection = getFieldsForType(selection2, parentType);
+    for (const fieldSelection of Object.values(targetSelection)) {
+      const { type: linkedType, keyRaw, selection: innerSelection } = fieldSelection;
       const key = evaluateKey(keyRaw, variables);
       for (const spec of subscribers) {
         this.addFieldSubscription({
           id: parent,
           key,
-          selection: fieldSelection,
+          field: fieldSelection,
           spec,
           parentType,
           variables
         });
       }
-      if (fields) {
+      if (innerSelection) {
         const { value: link } = this.cache._internal_unstable.storage.get(parent, key);
         const children = !Array.isArray(link) ? [link] : flattenList(link);
         for (const linkedRecord of children) {
@@ -54388,7 +54419,7 @@ var InMemorySubscriptions = class {
           }
           this.addMany({
             parent: linkedRecord,
-            selection: fields,
+            selection: innerSelection,
             variables,
             subscribers,
             parentType: linkedType
@@ -54400,22 +54431,20 @@ var InMemorySubscriptions = class {
   get(id, field) {
     return this.subscribers[id]?.[field] || [];
   }
-  remove(id, fields, targets, variables, visited = []) {
+  remove(id, selection2, targets, variables, visited = []) {
     visited.push(id);
     const linkedIDs = [];
-    for (const selection2 of Object.values(fields)) {
-      const key = evaluateKey(selection2.keyRaw, variables);
+    for (const fieldSelection of Object.values(selection2.fields || {})) {
+      const key = evaluateKey(fieldSelection.keyRaw, variables);
       this.removeSubscribers(id, key, targets);
-      if (!selection2.fields) {
+      if (!fieldSelection.selection?.fields) {
         continue;
       }
-      if (selection2.list) {
-      }
       const { value: previousValue } = this.cache._internal_unstable.storage.get(id, key);
       const links = !Array.isArray(previousValue) ? [previousValue] : flattenList(previousValue);
       for (const link of links) {
         if (link !== null) {
-          linkedIDs.push([link, selection2.fields]);
+          linkedIDs.push([link, fieldSelection.selection || {}]);
         }
       }
     }
@@ -54593,8 +54622,9 @@ var CacheInternal = class {
     if (this._disabled) {
       return [];
     }
+    let targetSelection = getFieldsForType(selection2, data["__typename"]);
     for (const [field, value] of Object.entries(data)) {
-      if (!selection2 || !selection2[field]) {
+      if (!selection2 || !targetSelection[field]) {
         throw new Error(
           "Could not find field listing in selection for " + field + " @ " + JSON.stringify(selection2)
         );
@@ -54602,11 +54632,11 @@ var CacheInternal = class {
       let {
         type: linkedType,
         keyRaw,
-        fields,
+        selection: fieldSelection,
         operations,
         abstract: isAbstract,
         update
-      } = selection2[field];
+      } = targetSelection[field];
       const key = evaluateKey(keyRaw, variables);
       const currentSubscribers = this.subscriptions.get(parent, key);
       const { value: previousValue, displayLayers } = this.storage.get(parent, key);
@@ -54614,7 +54644,7 @@ var CacheInternal = class {
       if (displayLayer) {
         this.lifetimes.resetLifetime(parent, key);
       }
-      if (!fields) {
+      if (!fieldSelection) {
         let newValue = value;
         if (Array.isArray(value) && applyUpdates && update) {
           if (update === "append") {
@@ -54634,7 +54664,7 @@ var CacheInternal = class {
         }
         const previousLinks = flattenList([previousValue]);
         for (const link of previousLinks) {
-          this.subscriptions.remove(link, fields, currentSubscribers, variables);
+          this.subscriptions.remove(link, fieldSelection, currentSubscribers, variables);
         }
         layer.writeLink(parent, key, null);
         toNotify.push(...currentSubscribers);
@@ -54660,14 +54690,14 @@ var CacheInternal = class {
           if (previousValue && typeof previousValue === "string") {
             this.subscriptions.remove(
               previousValue,
-              fields,
+              fieldSelection,
               currentSubscribers,
               variables
             );
           }
           this.subscriptions.addMany({
             parent: linkedID,
-            selection: fields,
+            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -54677,14 +54707,14 @@ var CacheInternal = class {
         if (linkedID) {
           this.writeSelection({
             root,
-            selection: fields,
+            selection: fieldSelection,
             parent: linkedID,
             data: value,
             variables,
             toNotify,
             applyUpdates,
             layer,
-            forceNotify: true
+            forceNotify
           });
         }
       } else if (Array.isArray(value) && (typeof previousValue === "undefined" || Array.isArray(previousValue))) {
@@ -54713,7 +54743,7 @@ var CacheInternal = class {
           key,
           linkedType,
           variables,
-          fields,
+          fields: fieldSelection,
           layer,
           forceNotify
         });
@@ -54763,7 +54793,7 @@ var CacheInternal = class {
           if (linkedIDs.includes(lostID) || !lostID) {
             continue;
           }
-          this.subscriptions.remove(lostID, fields, currentSubscribers, variables);
+          this.subscriptions.remove(lostID, fieldSelection, currentSubscribers, variables);
         }
         if (contentChanged || oldIDs.length === 0 && newIDs.length === 0) {
           layer.writeLink(parent, key, linkedIDs);
@@ -54774,7 +54804,7 @@ var CacheInternal = class {
           }
           this.subscriptions.addMany({
             parent: id,
-            selection: fields,
+            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -54799,9 +54829,14 @@ var CacheInternal = class {
         }
         const targets = Array.isArray(value) ? value : [value];
         for (const target of targets) {
-          if (operation.action === "insert" && target instanceof Object && fields && operation.list) {
-            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).addToList(fields, target, variables, operation.position || "last");
-          } else if (operation.action === "remove" && target instanceof Object && fields && operation.list) {
+          if (operation.action === "insert" && target instanceof Object && fieldSelection && operation.list) {
+            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).addToList(
+              fieldSelection,
+              target,
+              variables,
+              operation.position || "last"
+            );
+          } else if (operation.action === "remove" && target instanceof Object && fieldSelection && operation.list) {
             this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).remove(target, variables);
           } else if (operation.action === "delete" && operation.type) {
             if (typeof target !== "string") {
@@ -54812,8 +54847,13 @@ var CacheInternal = class {
               continue;
             }
             this.cache.delete(targetID);
-          } else if (operation.action === "toggle" && target instanceof Object && fields && operation.list) {
-            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).toggleElement(fields, target, variables, operation.position || "last");
+          } else if (operation.action === "toggle" && target instanceof Object && fieldSelection && operation.list) {
+            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).toggleElement(
+              fieldSelection,
+              target,
+              variables,
+              operation.position || "last"
+            );
           }
         }
       }
@@ -54833,9 +54873,12 @@ var CacheInternal = class {
     let hasData = false;
     let partial = false;
     let cascadeNull = false;
-    for (const [attributeName, { type, keyRaw, fields, nullable, list }] of Object.entries(
-      selection2
-    )) {
+    const typename = this.storage.get(parent, "__typename").value;
+    let targetSelection = getFieldsForType(selection2, typename);
+    for (const [
+      attributeName,
+      { type, keyRaw, selection: fieldSelection, nullable, list }
+    ] of Object.entries(targetSelection)) {
       const key = evaluateKey(keyRaw, variables);
       const { value } = this.storage.get(parent, key);
       let nextStep = stepsFromConnection;
@@ -54858,7 +54901,7 @@ var CacheInternal = class {
         if (typeof value !== "undefined") {
           hasData = true;
         }
-      } else if (!fields) {
+      } else if (!fieldSelection) {
         const fnUnmarshal = this.config?.scalars?.[type]?.unmarshal;
         if (fnUnmarshal) {
           target[attributeName] = fnUnmarshal(value);
@@ -54868,7 +54911,7 @@ var CacheInternal = class {
         hasData = true;
       } else if (Array.isArray(value)) {
         const listValue = this.hydrateNestedList({
-          fields,
+          fields: fieldSelection,
           variables,
           linkedList: value,
           stepsFromConnection: nextStep
@@ -54883,7 +54926,7 @@ var CacheInternal = class {
       } else {
         const objectFields = this.getSelection({
           parent: value,
-          selection: fields,
+          selection: fieldSelection,
           variables,
           stepsFromConnection: nextStep
         });
@@ -55385,7 +55428,7 @@ var Config = class {
   typeConfig;
   configFile;
   logLevel;
-  disableMasking;
+  defaultFragmentMasking = "enable";
   configIsRoute = null;
   routesDir;
   schemaPollInterval;
@@ -55398,6 +55441,11 @@ var Config = class {
     ...configFile
   }) {
     this.configFile = defaultConfigValues(configFile);
+    if (configFile.disableMasking !== void 0) {
+      throw new HoudiniError({
+        message: `"disableMasking" was replaced by "defaultFragmentMasking". Please update your config file.`
+      });
+    }
     let {
       schema,
       schemaPath = "./schema.graphql",
@@ -55414,7 +55462,7 @@ var Config = class {
       defaultKeys,
       types: types12 = {},
       logLevel,
-      disableMasking = false,
+      defaultFragmentMasking = "enable",
       schemaPollInterval = 2e3,
       schemaPollHeaders = {},
       projectDir
@@ -55433,7 +55481,11 @@ var Config = class {
       logLevel = LogLevel.Summary;
     }
     this.schemaPath = schemaPath;
-    this.apiUrl = apiUrl;
+    if (apiUrl && apiUrl.startsWith("env:")) {
+      this.apiUrl = process.env[apiUrl.slice("env:".length)];
+    } else {
+      this.apiUrl = apiUrl;
+    }
     this.filepath = filepath;
     this.exclude = Array.isArray(exclude) ? exclude : [exclude];
     this.module = module2;
@@ -55445,10 +55497,10 @@ var Config = class {
     this.defaultCachePolicy = defaultCachePolicy;
     this.defaultPartial = defaultPartial;
     this.internalListPosition = defaultListPosition === "append" ? "last" : "first";
-    this.defaultListTarget == defaultListTarget;
+    this.defaultListTarget = defaultListTarget;
     this.definitionsFolder = definitionsPath;
     this.logLevel = (logLevel || LogLevel.Summary).toLowerCase();
-    this.disableMasking = disableMasking;
+    this.defaultFragmentMasking = defaultFragmentMasking;
     this.routesDir = join(this.projectRoot, "src", "routes");
     this.schemaPollInterval = schemaPollInterval;
     this.schemaPollHeaders = schemaPollHeaders;
@@ -55642,8 +55694,14 @@ var Config = class {
   pluginDirectory(name2) {
     return houdini_mode.is_testing ? resolve("../../../", name2) : join(this.rootDir, "plugins", name2);
   }
-  get houdiniDirective() {
-    return "houdini";
+  get manualLoadDirective() {
+    return "manual_load";
+  }
+  get maskEnableDirective() {
+    return "mask_enable";
+  }
+  get maskDisableDirective() {
+    return "mask_disable";
   }
   get listDirective() {
     return "list";
@@ -55655,9 +55713,9 @@ var Config = class {
     return "append";
   }
   get listParentDirective() {
-    return this.listDirectiveParentIDArg;
+    return "parentID";
   }
-  get listDirectiveParentIDArg() {
+  get deprecatedlistDirectiveParentIDArg() {
     return "parentID";
   }
   get listAllListsDirective() {
@@ -55743,7 +55801,7 @@ var Config = class {
       this.listDirective,
       this.listPrependDirective,
       this.listAppendDirective,
-      this.listDirectiveParentIDArg,
+      this.listParentDirective,
       this.listAllListsDirective,
       this.whenDirective,
       this.whenNotDirective,
@@ -55751,7 +55809,9 @@ var Config = class {
       this.withDirective,
       this.paginateDirective,
       this.cacheDirective,
-      this.houdiniDirective
+      this.manualLoadDirective,
+      this.maskEnableDirective,
+      this.maskDisableDirective
     ].includes(name2.value) || this.isDeleteDirective(name2.value);
   }
   isListFragment(name2) {
@@ -55988,13 +56048,17 @@ function flattenSelections({
   config: config2,
   filepath,
   selections,
-  fragmentDefinitions
+  fragmentDefinitions,
+  applyFragments,
+  ignoreMaskDisable
 }) {
   const fields = new FieldCollection({
     config: config2,
     filepath,
     selections,
-    fragmentDefinitions
+    fragmentDefinitions,
+    applyFragments,
+    ignoreMaskDisable: !!ignoreMaskDisable
   });
   return fields.toSelectionSet();
 }
@@ -56005,9 +56069,13 @@ var FieldCollection = class {
   fields;
   inlineFragments;
   fragmentSpreads;
+  applyFragments;
+  ignoreMaskDisable;
   constructor(args) {
     this.config = args.config;
     this.fragmentDefinitions = args.fragmentDefinitions;
+    this.applyFragments = args.applyFragments;
+    this.ignoreMaskDisable = args.ignoreMaskDisable;
     this.fields = {};
     this.inlineFragments = {};
     this.fragmentSpreads = {};
@@ -56036,31 +56104,28 @@ var FieldCollection = class {
       }
     }
     if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
-      const key = selection2.typeCondition.name.value;
-      if (!this.inlineFragments[key]) {
-        this.inlineFragments[key] = {
-          astNode: selection2,
-          selection: this.empty()
-        };
-      }
-      for (const subselect of selection2.selectionSet?.selections || []) {
-        this.inlineFragments[key].selection.add(subselect);
-      }
+      this.walkInlineFragment(selection2);
       return;
     }
     if (selection2.kind === "FragmentSpread") {
       this.fragmentSpreads[selection2.name.value] = selection2;
-      const houdiniDirective = selection2.directives?.find(
-        ({ name: name2 }) => name2.value === this.config.houdiniDirective
+      let includeFragments = this.config.defaultFragmentMasking === "disable";
+      const maskEnableDirective = selection2.directives?.find(
+        ({ name: name2 }) => name2.value === this.config.maskEnableDirective
       );
-      const maskArgument = houdiniDirective?.arguments?.find(
-        ({ name: name2 }) => name2.value === "mask"
+      if (maskEnableDirective) {
+        includeFragments = false;
+      }
+      const maskDisableDirective = selection2.directives?.find(
+        ({ name: name2 }) => name2.value === this.config.maskDisableDirective
       );
-      let includeFragments = this.config.disableMasking;
-      if (maskArgument?.value.kind === "BooleanValue") {
-        includeFragments = !maskArgument.value.value;
+      if (maskDisableDirective) {
+        includeFragments = true;
+      }
+      if (this.ignoreMaskDisable) {
+        includeFragments = true;
       }
-      if (!includeFragments) {
+      if (!includeFragments || !this.applyFragments) {
         return;
       }
       const definition = this.fragmentDefinitions[selection2.name.value];
@@ -56070,9 +56135,20 @@ var FieldCollection = class {
           message: "Could not find referenced fragment definition: " + selection2.name.value
         });
       }
-      for (const subselect of definition.selectionSet.selections) {
-        this.add(subselect);
-      }
+      this.add({
+        kind: "InlineFragment",
+        typeCondition: {
+          kind: "NamedType",
+          name: {
+            kind: "Name",
+            value: definition.typeCondition.name.value
+          }
+        },
+        selectionSet: {
+          kind: "SelectionSet",
+          selections: [...definition.selectionSet.selections]
+        }
+      });
     }
   }
   toSelectionSet() {
@@ -56088,12 +56164,30 @@ var FieldCollection = class {
       })
     ).concat(Object.values(this.fragmentSpreads));
   }
+  walkInlineFragment(selection2) {
+    const key = selection2.typeCondition.name.value;
+    if (!this.inlineFragments[key]) {
+      this.inlineFragments[key] = {
+        astNode: selection2,
+        selection: this.empty()
+      };
+    }
+    for (const subselect of selection2.selectionSet.selections || []) {
+      if (subselect.kind !== "InlineFragment" || !subselect.typeCondition) {
+        this.inlineFragments[key].selection.add(subselect);
+        continue;
+      }
+      this.walkInlineFragment(subselect);
+    }
+  }
   empty() {
     return new FieldCollection({
       config: this.config,
       fragmentDefinitions: this.fragmentDefinitions,
       selections: [],
-      filepath: this.filepath
+      filepath: this.filepath,
+      applyFragments: this.applyFragments,
+      ignoreMaskDisable: this.ignoreMaskDisable
     });
   }
 };
@@ -56448,11 +56542,6 @@ function operationObject({
     const when = internalDirectives.find(({ name: name2 }) => name2.value === "when");
     const when_not = internalDirectives.find(({ name: name2 }) => name2.value === "when_not");
     let parentIDArg = parent?.arguments?.find((argument) => argument.name.value === "value");
-    if (!parentIDArg) {
-      parentIDArg = (append || prepend)?.arguments?.find(
-        ({ name: name2 }) => name2.value === config2.listDirectiveParentIDArg
-      );
-    }
     if (parentIDArg) {
       if (parentIDArg.value.kind === "StringValue") {
         parentID = parentIDArg.value.value;
@@ -57480,6 +57569,8 @@ function selection({
   markEdges
 }) {
   let object = {};
+  const typeMap = {};
+  const abstractTypes = [];
   for (const field of selections) {
     if (field.kind === "FragmentSpread" && includeFragments) {
       const fragmentDefinition = document.document.definitions.find(
@@ -57506,20 +57597,68 @@ function selection({
         })
       );
     } else if (field.kind === "InlineFragment") {
-      object = deepMerge(
-        filepath,
-        object,
-        selection({
-          config: config2,
+      if (!field.typeCondition || field.typeCondition.name.value === rootType) {
+        object.fields = deepMerge(
           filepath,
-          rootType: field.typeCondition?.name.value || rootType,
-          operations,
-          selections: field.selectionSet.selections,
-          path: path2,
-          includeFragments,
-          document
-        })
-      );
+          object.fields || {},
+          selection({
+            config: config2,
+            filepath,
+            rootType: field.typeCondition?.name.value || rootType,
+            operations,
+            selections: field.selectionSet.selections,
+            path: path2,
+            includeFragments,
+            document
+          }).fields || {}
+        );
+      } else {
+        if (!object.abstractFields) {
+          object.abstractFields = {
+            fields: {},
+            typeMap: {}
+          };
+        }
+        const parentType = config2.schema.getType(rootType);
+        const typeConditionName = field.typeCondition.name.value;
+        const typeCondition = config2.schema.getType(typeConditionName);
+        const possibleTypes = [];
+        if (!graphql10.isAbstractType(typeCondition)) {
+        } else if (graphql10.isAbstractType(parentType)) {
+          const possibleParentTypes = config2.schema.getPossibleTypes(parentType).map((type) => type.name);
+          for (const possible of config2.schema.getPossibleTypes(typeCondition)) {
+            if (possibleParentTypes.includes(possible.name)) {
+              possibleTypes.push(possible.name);
+            }
+          }
+        } else {
+          possibleTypes.push(rootType);
+        }
+        if (possibleTypes.length > 0) {
+          for (const type of possibleTypes) {
+            const existing = typeMap[type];
+            if (!existing || !existing.includes(type)) {
+              typeMap[type] = [typeConditionName].concat(existing || []);
+            }
+            if (!abstractTypes.includes(typeConditionName)) {
+              abstractTypes.push(typeConditionName);
+            }
+          }
+        }
+        object.abstractFields.fields = {
+          ...object.abstractFields.fields,
+          [field.typeCondition.name.value]: selection({
+            config: config2,
+            filepath,
+            rootType: field.typeCondition?.name.value || rootType,
+            operations,
+            selections: field.selectionSet.selections,
+            path: path2,
+            includeFragments,
+            document
+          }).fields
+        };
+      }
     } else if (field.kind === "Field") {
       const type = config2.schema.getType(rootType);
       if (!type) {
@@ -57577,7 +57716,7 @@ function selection({
       }
       if (field.selectionSet) {
         const edgesMark = paginated && document.refetch?.method === "cursor" ? document.refetch.update : markEdges;
-        fieldObj.fields = selection({
+        fieldObj.selection = selection({
           config: config2,
           filepath,
           rootType: typeName,
@@ -57601,11 +57740,49 @@ function selection({
       if (graphql10.isInterfaceType(fieldType) || graphql10.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
-      object[attributeName] = deepMerge(
-        filepath,
-        fieldObj,
-        object[attributeName] || {}
-      );
+      object.fields = {
+        ...object.fields,
+        [attributeName]: fieldObj
+      };
+    }
+  }
+  if (Object.keys(object.fields || {}).length > 0 && object.abstractFields && Object.keys(object.abstractFields.fields).length > 0) {
+    for (const [typeName, possibles] of Object.entries(typeMap)) {
+      let overlap = false;
+      for (const possible of possibles) {
+        if (object.abstractFields.fields[typeName]) {
+          object.abstractFields.fields[typeName] = deepMerge(
+            filepath,
+            object.abstractFields.fields[typeName] || {},
+            object.abstractFields.fields[possible]
+          );
+          overlap = true;
+        }
+      }
+      if (overlap) {
+        delete typeMap[typeName];
+      }
+    }
+    for (const [type, options] of Object.entries(typeMap)) {
+      if (options.length > 1) {
+        object.abstractFields.fields[type] = deepMerge(
+          filepath,
+          ...options.map((opt) => object.abstractFields.fields[opt] || {})
+        );
+        delete typeMap[type];
+      }
+    }
+    for (const [type, sel] of Object.entries(object.abstractFields?.fields || {})) {
+      object.abstractFields.fields[type] = deepMerge(filepath, sel || {}, object.fields);
+    }
+    for (const [type, options] of Object.entries(typeMap)) {
+      object.abstractFields.typeMap[type] = options[0];
+    }
+    const usedTypes = Object.values(object.abstractFields.typeMap);
+    for (const type of abstractTypes) {
+      if (!usedTypes.includes(type)) {
+        delete object.abstractFields.fields[type];
+      }
     }
   }
   return object;
@@ -57740,6 +57917,22 @@ function artifactGenerator(stats) {
             selectionSet = matchingFragment.selectionSet;
           }
           const inputs = operations[0]?.variableDefinitions;
+          const mergedSelection = flattenSelections({
+            config: config2,
+            filepath: doc.filename,
+            selections: selectionSet.selections,
+            fragmentDefinitions: doc.document.definitions.filter(
+              (definition) => definition.kind === "FragmentDefinition"
+            ).reduce(
+              (prev, definition) => ({
+                ...prev,
+                [definition.name.value]: definition
+              }),
+              {}
+            ),
+            ignoreMaskDisable: docKind === "HoudiniQuery",
+            applyFragments: docKind !== "HoudiniFragment"
+          });
           const artifact = {
             name: name2,
             kind: docKind,
@@ -57751,7 +57944,7 @@ function artifactGenerator(stats) {
               config: config2,
               filepath: doc.filename,
               rootType,
-              selections: selectionSet.selections,
+              selections: mergedSelection,
               operations: operationsByPath(
                 config2,
                 doc.filename,
@@ -58047,6 +58240,17 @@ function inlineType({
           continue;
         }
         const possibleParents = config2.schema.getPossibleTypes(type).map((t) => t.name);
+        const freeSelections = [];
+        const typeSpecificSelections = {};
+        for (const node of selection2.selectionSet.selections) {
+          if (node.kind !== "InlineFragment") {
+            freeSelections.push(node);
+          } else if (node.typeCondition) {
+            typeSpecificSelections[node.typeCondition.name.value] = node.selectionSet.selections;
+          } else {
+            freeSelections.push(...node.selectionSet.selections);
+          }
+        }
         for (const possibleType of config2.schema.getPossibleTypes(fragmentType)) {
           if (!possibleParents.includes(possibleType.name)) {
             continue;
@@ -58054,7 +58258,12 @@ function inlineType({
           if (!inlineFragments[possibleType.name]) {
             inlineFragments[possibleType.name] = [];
           }
-          inlineFragments[possibleType.name].push(...selection2.selectionSet.selections);
+          inlineFragments[possibleType.name].push(...freeSelections);
+          if (typeSpecificSelections[possibleType.name]) {
+            inlineFragments[possibleType.name].push(
+              ...typeSpecificSelections[possibleType.name]
+            );
+          }
         }
       } else if (selection2.kind === "InlineFragment" && !selection2.typeCondition) {
         selectedFields.push(...selection2.selectionSet.selections);
@@ -58066,12 +58275,7 @@ function inlineType({
       ...(selectedFields || []).filter(
         (field) => field.kind === "Field"
       ).map((selection2) => {
-        const { type: type2, field } = selectionTypeInfo(
-          config2.schema,
-          filepath,
-          rootObj,
-          selection2
-        );
+        const { field } = selectionTypeInfo(config2.schema, filepath, rootObj, selection2);
         const attributeName = selection2.alias?.value || selection2.name.value;
         let attributeType = inlineType({
           config: config2,
@@ -58270,7 +58474,8 @@ async function typescriptGenerator(config2, docs) {
         config: config2,
         filepath: filename,
         selections: definition.selectionSet.selections,
-        fragmentDefinitions
+        fragmentDefinitions,
+        applyFragments: definition.kind === "OperationDefinition"
       });
       if (definition?.kind === "OperationDefinition") {
         await generateOperationTypeDefs(
@@ -58783,14 +58988,12 @@ directive @${config2.paginateDirective}(${config2.paginateNameArg}: String) on F
 """
 	@${config2.listPrependDirective} is used to tell the runtime to add the result to the end of the list
 """
-directive @${config2.listPrependDirective}(
-	${config2.listDirectiveParentIDArg}: ID
-) on FRAGMENT_SPREAD
+directive @${config2.listPrependDirective} on FRAGMENT_SPREAD
 
 """
 	@${config2.listAppendDirective} is used to tell the runtime to add the result to the start of the list
 """
-directive @${config2.listAppendDirective}(${config2.listDirectiveParentIDArg}: ID) on FRAGMENT_SPREAD
+directive @${config2.listAppendDirective} on FRAGMENT_SPREAD
 
 """
 	@${config2.listAllListsDirective} is used to tell the runtime to add the result to all list
@@ -58824,18 +59027,19 @@ directive @${config2.argumentsDirective} on FRAGMENT_DEFINITION
 directive @${config2.cacheDirective}(${config2.cachePolicyArg}: CachePolicy, ${config2.cachePartialArg}: Boolean) on QUERY
 
 """
-	@${config2.houdiniDirective} is used to configure houdini's internal behavior
+	@${config2.manualLoadDirective} is used to disable automatic fetch (no load, no auto fetch in component), you will have to do it manually.
 """
-directive @${config2.houdiniDirective}(
-	"""
-	Opt-in to an automatic load function (only valid when used at queries)
-	"""
-	load: Boolean! = true
-	"""
-	Mask fragment fields (only valid when used at a fragment spread)
-	"""
-	mask: Boolean! = ${config2.disableMasking ? "false" : "true"}
-) on QUERY | FRAGMENT_SPREAD
+directive @${config2.manualLoadDirective} on QUERY
+
+"""
+	@${config2.maskEnableDirective} to enable masking on fragment (overwriting the global conf)
+"""
+directive @${config2.maskEnableDirective} on FRAGMENT_SPREAD
+
+"""
+	@${config2.maskDisableDirective} to disable masking on fragment (overwriting the global conf)
+"""
+directive @${config2.maskDisableDirective} on FRAGMENT_SPREAD
 `;
   let currentSchema = graphql19.printSchema(config2.schema);
   if (!currentSchema.includes(`directive @${config2.listDirective}`)) {
@@ -59328,26 +59532,42 @@ async function typeCheck(config2, docs) {
           ),
           targetField.selectionSet
         );
-        const missingIDFields = config2.keyFieldsForType(type.name).filter((fieldName) => !type.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(
-                  ", "
-                )}.`
-              })
-            );
+        let targetTypes = [type];
+        if (graphql23.isUnionType(type)) {
+          targetTypes = config2.schema.getPossibleTypes(type);
+        } else if (graphql23.isInterfaceType(type)) {
+          try {
+            for (const key of config2.keyFieldsForType(type.name)) {
+              if (!type.getFields()[key]) {
+                throw new Error("continue");
+              }
+            }
+          } catch {
+            targetTypes = config2.schema.getPossibleTypes(type);
+          }
+        }
+        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(
+                    ", "
+                  )}.`
+                })
+              );
+            }
+            return;
           }
-          return;
         }
         lists.push(listName);
         listTypes.push(type.name);
@@ -59377,6 +59597,7 @@ async function typeCheck(config2, docs) {
       fragments
     }),
     checkMutationOperation(config2),
+    checkMaskDirective(config2),
     nodeDirectives(config2, [config2.paginateDirective]),
     knownArguments(config2),
     validateFragmentArguments(config2, filepath, fragments),
@@ -59441,10 +59662,14 @@ var validateLists = ({
       ]);
       if (directive) {
         let parentArg = directive.arguments?.find(
-          (arg) => arg.name.value === config2.listDirectiveParentIDArg
+          (arg) => arg.name.value === config2.deprecatedlistDirectiveParentIDArg
         );
         if (parentArg) {
-          parentIdFound = true;
+          ctx.reportError(
+            new graphql23.GraphQLError(
+              `@${config2.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
+            )
+          );
         }
       }
       if (parentIdFound) {
@@ -59840,6 +60065,28 @@ function checkMutationOperation(config2) {
     };
   };
 }
+function checkMaskDirective(config2) {
+  return function(ctx) {
+    return {
+      FragmentSpread(node, _, __, ___, ancestors) {
+        const maskEnableDirective = node.directives?.find(
+          (c) => c.name.value === config2.maskEnableDirective
+        );
+        const maskDisableDirective = node.directives?.find(
+          (c) => c.name.value === config2.maskDisableDirective
+        );
+        if (maskEnableDirective && maskDisableDirective) {
+          ctx.reportError(
+            new graphql23.GraphQLError(
+              `You can't apply both @${config2.maskEnableDirective} and @${config2.maskDisableDirective} at the same time`
+            )
+          );
+          return;
+        }
+      }
+    };
+  };
+}
 function getAndVerifyNodeInterface(config2) {
   const { schema } = config2;
   const nodeInterface = schema.getType("Node");
@@ -60118,8 +60365,9 @@ function testConfigFile(config2 = {}) {
 			scalar Cursor
 
 
-			type User implements Node {
+			type User implements Node & Friend & CatOwner {
 				id: ID!
+				name: String!
 				firstName: String!
 				friends: [User!]!
 				friendsByCursor(first: Int, after: String, last: Int, before: String, filter: String): UserConnection!
@@ -60134,13 +60382,14 @@ function testConfigFile(config2 = {}) {
 				field(filter: String): String
 			}
 
-			type Ghost implements Friend {
+			type Ghost implements Friend & CatOwner & IsGhost {
 				name: String!
 				aka: String!
 				believers: [User!]!
 				friends: [Ghost!]!
 				friendsConnection(first: Int, after: String): GhostConnection!
 				legends: [Legend!]!
+				cats: [Cat!]!
 			}
 
 			type Legend {
@@ -60166,6 +60415,9 @@ function testConfigFile(config2 = {}) {
 				usersByBackwardsCursor(last: Int, before: String): UserConnection!
 				usersByForwardsCursor(first: Int, after: String): UserConnection!
 				usersByOffset(offset: Int, limit: Int): [User!]!
+				friendsByCursor(first: Int, after: String, last: Int, before: String): FriendConnection!
+				ghostsByCursor(first: Int, after: String, last: Int, before: String): IsGhostConnection!
+				entitiesByCursor(first: Int, after: String, last: Int, before: String): EntityConnection!
 				node(id: ID!): Node
 			}
 
@@ -60181,16 +60433,26 @@ function testConfigFile(config2 = {}) {
 				node: User
 			}
 
-			type UserEdgeScalar {
-				cursor: Cursor!
-				node: User
-			}
-
 			type UserConnection {
 				pageInfo: PageInfo!
 				edges: [UserEdge!]!
 			}
 
+			type FriendEdge {
+				cursor: String!
+				node: Friend
+			}
+
+			type FriendConnection {
+				pageInfo: PageInfo!
+				edges: [FriendEdge!]!
+			}
+
+			type UserEdgeScalar {
+				cursor: Cursor!
+				node: User
+			}
+
 			type UserConnectionScalar {
 				pageInfo: PageInfo!
 				edges: [UserEdgeScalar!]!
@@ -60206,10 +60468,38 @@ function testConfigFile(config2 = {}) {
 				edges: [GhostEdge!]!
 			}
 
+			type EntityEdge {
+				cursor: String!
+				node: Entity
+			}
+
+			type EntityConnection {
+				pageInfo: PageInfo!
+				edges: [EntityEdge!]!
+			}
+
+			type IsGhostEdge {
+				cursor: String!
+				node: IsGhost
+			}
+
+			type IsGhostConnection {
+				pageInfo: PageInfo!
+				edges: [IsGhostEdge!]!
+			}
+
 			interface Friend {
 				name: String!
 			}
 
+			interface CatOwner {
+				cats: [Cat!]!
+			}
+
+			interface IsGhost { 
+				aka: String!
+			}
+
 			union Entity = User | Cat | Ghost
 
 			type Mutation {
@@ -60306,13 +60596,13 @@ function pipelineTest(config2, documents, shouldPass, testBody) {
       await runPipeline2(config2, docs);
     } catch (e) {
       if (shouldPass) {
-        throw e;
+        console.error(e);
+        throw "pipeline failed when it should have passed";
       }
       error = e;
     }
     if (!shouldPass && error.length === 0) {
-      throw "did not fail test";
-      return;
+      throw "pipeline shouldn't have passed!";
     }
     if (testBody) {
       testBody(shouldPass ? docs : error);