houdini 0.17.14 → 0.18.1

package/build/codegen-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)) {
@@ -53462,6 +53462,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;
@@ -53684,23 +53698,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"
+                            }
+                          }
+                        }
+                      }
                     }
                   }
                 }
@@ -53716,15 +53739,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"
+                }
+              }
             }
           }
         }
@@ -53784,7 +53812,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
     );
@@ -54273,18 +54301,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
@@ -54297,7 +54327,7 @@ var InMemorySubscriptions = class {
           this.add({
             parent: child,
             spec,
-            selection: fields,
+            selection: innerSelection,
             variables,
             parentType: type
           });
@@ -54308,7 +54338,7 @@ var InMemorySubscriptions = class {
   addFieldSubscription({
     id,
     key,
-    selection: selection2,
+    field,
     spec,
     parentType,
     variables
@@ -54335,8 +54365,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,
@@ -54344,7 +54374,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,
@@ -54361,20 +54391,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) {
@@ -54383,7 +54414,7 @@ var InMemorySubscriptions = class {
           }
           this.addMany({
             parent: linkedRecord,
-            selection: fields,
+            selection: innerSelection,
             variables,
             subscribers,
             parentType: linkedType
@@ -54395,22 +54426,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 || {}]);
         }
       }
     }
@@ -54565,10 +54594,12 @@ var CacheInternal = class {
     this.lists = lists;
     this.cache = cache;
     this.lifetimes = lifetimes;
+    this._disabled = typeof globalThis.window === "undefined";
     try {
-      this._disabled = process.env.HOUDINI_TEST !== "true";
+      if (process.env.HOUDINI_TEST === "true") {
+        this._disabled = false;
+      }
     } catch {
-      this._disabled = typeof globalThis.window === "undefined";
     }
   }
   setConfig(config2) {
@@ -54588,8 +54619,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)
         );
@@ -54597,11 +54629,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);
@@ -54609,7 +54641,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") {
@@ -54629,7 +54661,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);
@@ -54655,14 +54687,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
@@ -54672,14 +54704,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))) {
@@ -54708,7 +54740,7 @@ var CacheInternal = class {
           key,
           linkedType,
           variables,
-          fields,
+          fields: fieldSelection,
           layer,
           forceNotify
         });
@@ -54758,7 +54790,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);
@@ -54769,7 +54801,7 @@ var CacheInternal = class {
           }
           this.subscriptions.addMany({
             parent: id,
-            selection: fields,
+            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -54794,9 +54826,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") {
@@ -54807,8 +54844,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"
+            );
           }
         }
       }
@@ -54828,9 +54870,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;
@@ -54853,7 +54898,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);
@@ -54863,7 +54908,7 @@ var CacheInternal = class {
         hasData = true;
       } else if (Array.isArray(value)) {
         const listValue = this.hydrateNestedList({
-          fields,
+          fields: fieldSelection,
           variables,
           linkedList: value,
           stepsFromConnection: nextStep
@@ -54878,7 +54923,7 @@ var CacheInternal = class {
       } else {
         const objectFields = this.getSelection({
           parent: value,
-          selection: fields,
+          selection: fieldSelection,
           variables,
           stepsFromConnection: nextStep
         });
@@ -55707,13 +55752,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();
 }
@@ -55724,9 +55773,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 = {};
@@ -55755,31 +55808,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 (!includeFragments) {
+      if (this.ignoreMaskDisable) {
+        includeFragments = true;
+      }
+      if (!includeFragments || !this.applyFragments) {
         return;
       }
       const definition = this.fragmentDefinitions[selection2.name.value];
@@ -55789,9 +55839,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() {
@@ -55807,12 +55868,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
     });
   }
 };
@@ -56167,11 +56246,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;
@@ -57199,6 +57273,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(
@@ -57225,20 +57301,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) {
@@ -57296,7 +57420,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,
@@ -57320,11 +57444,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;
@@ -57459,6 +57621,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,
@@ -57470,7 +57648,7 @@ function artifactGenerator(stats) {
               config: config2,
               filepath: doc.filename,
               rootType,
-              selections: selectionSet.selections,
+              selections: mergedSelection,
               operations: operationsByPath(
                 config2,
                 doc.filename,
@@ -57766,6 +57944,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;
@@ -57773,7 +57962,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);
@@ -57785,12 +57979,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,
@@ -57989,7 +58178,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(
@@ -58502,14 +58692,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
@@ -58543,18 +58731,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.manualLoadDirective} on QUERY
+
 """
-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
+	@${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}`)) {
@@ -59047,26 +59236,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);
@@ -59096,6 +59301,7 @@ async function typeCheck(config2, docs) {
       fragments
     }),
     checkMutationOperation(config2),
+    checkMaskDirective(config2),
     nodeDirectives(config2, [config2.paginateDirective]),
     knownArguments(config2),
     validateFragmentArguments(config2, filepath, fragments),
@@ -59160,10 +59366,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) {
@@ -59559,6 +59769,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");
@@ -59856,12 +60088,7 @@ async function collectDocuments(config2) {
 }
 async function processJSFile(config2, contents) {
   const documents = [];
-  try {
-    var program = (await parseJS(contents)).script;
-  } catch (e) {
-    console.log(contents);
-    throw e;
-  }
+  var program = (await parseJS(contents)).script;
   await find_graphql(config2, program, {
     tag({ tagContent }) {
       documents.push(tagContent);