houdini 0.17.13 → 0.18.0

package/build/vite-esm/index.js

@@ -6779,7 +6779,7 @@ var require_definition = __commonJS({
     exports.assertObjectType = assertObjectType;
     exports.isInterfaceType = isInterfaceType12;
     exports.assertInterfaceType = assertInterfaceType;
-    exports.isUnionType = isUnionType12;
+    exports.isUnionType = isUnionType13;
     exports.assertUnionType = assertUnionType;
     exports.isEnumType = isEnumType9;
     exports.assertEnumType = assertEnumType;
@@ -6797,7 +6797,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 = GraphQLList6;
     exports.GraphQLNonNull = GraphQLNonNull6;
@@ -6852,7 +6852,7 @@ var require_definition = __commonJS({
       return Constructor;
     }
     function isType(type) {
-      return isScalarType12(type) || isObjectType11(type) || isInterfaceType12(type) || isUnionType12(type) || isEnumType9(type) || isInputObjectType7(type) || isListType8(type) || isNonNullType10(type);
+      return isScalarType12(type) || isObjectType11(type) || isInterfaceType12(type) || isUnionType13(type) || isEnumType9(type) || isInputObjectType7(type) || isListType8(type) || isNonNullType10(type);
     }
     function assertType(type) {
       if (!isType(type)) {
@@ -6887,11 +6887,11 @@ var require_definition = __commonJS({
       }
       return type;
     }
-    function isUnionType12(type) {
+    function isUnionType13(type) {
       return (0, _instanceOf.default)(type, GraphQLUnionType3);
     }
     function assertUnionType(type) {
-      if (!isUnionType12(type)) {
+      if (!isUnionType13(type)) {
         throw new Error("Expected ".concat((0, _inspect.default)(type), " to be a GraphQL Union type."));
       }
       return type;
@@ -6942,7 +6942,7 @@ var require_definition = __commonJS({
       return type;
     }
     function isOutputType(type) {
-      return isScalarType12(type) || isObjectType11(type) || isInterfaceType12(type) || isUnionType12(type) || isEnumType9(type) || isWrappingType(type) && isOutputType(type.ofType);
+      return isScalarType12(type) || isObjectType11(type) || isInterfaceType12(type) || isUnionType13(type) || isEnumType9(type) || isWrappingType(type) && isOutputType(type.ofType);
     }
     function assertOutputType(type) {
       if (!isOutputType(type)) {
@@ -6960,7 +6960,7 @@ var require_definition = __commonJS({
       return type;
     }
     function isCompositeType(type) {
-      return isObjectType11(type) || isInterfaceType12(type) || isUnionType12(type);
+      return isObjectType11(type) || isInterfaceType12(type) || isUnionType13(type);
     }
     function assertCompositeType(type) {
       if (!isCompositeType(type)) {
@@ -6968,11 +6968,11 @@ var require_definition = __commonJS({
       }
       return type;
     }
-    function isAbstractType(type) {
-      return isInterfaceType12(type) || isUnionType12(type);
+    function isAbstractType2(type) {
+      return isInterfaceType12(type) || isUnionType13(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;
@@ -7039,7 +7039,7 @@ var require_definition = __commonJS({
       }
     }
     function isNamedType4(type) {
-      return isScalarType12(type) || isObjectType11(type) || isInterfaceType12(type) || isUnionType12(type) || isEnumType9(type) || isInputObjectType7(type);
+      return isScalarType12(type) || isObjectType11(type) || isInterfaceType12(type) || isUnionType13(type) || isEnumType9(type) || isInputObjectType7(type);
     }
     function assertNamedType(type) {
       if (!isNamedType4(type)) {
@@ -63884,6 +63884,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;
@@ -64106,23 +64120,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"
+                            }
+                          }
+                        }
+                      }
                     }
                   }
                 }
@@ -64138,15 +64161,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"
+                }
+              }
             }
           }
         }
@@ -64206,7 +64234,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
     );
@@ -64695,18 +64723,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
@@ -64719,7 +64749,7 @@ var InMemorySubscriptions = class {
           this.add({
             parent: child,
             spec,
-            selection: fields,
+            selection: innerSelection,
             variables,
             parentType: type
           });
@@ -64730,7 +64760,7 @@ var InMemorySubscriptions = class {
   addFieldSubscription({
     id,
     key,
-    selection: selection2,
+    field,
     spec,
     parentType,
     variables
@@ -64757,8 +64787,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,
@@ -64766,7 +64796,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,
@@ -64783,20 +64813,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) {
@@ -64805,7 +64836,7 @@ var InMemorySubscriptions = class {
           }
           this.addMany({
             parent: linkedRecord,
-            selection: fields,
+            selection: innerSelection,
             variables,
             subscribers,
             parentType: linkedType
@@ -64817,22 +64848,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 || {}]);
         }
       }
     }
@@ -65010,8 +65039,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)
         );
@@ -65019,11 +65049,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);
@@ -65031,7 +65061,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") {
@@ -65051,7 +65081,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);
@@ -65077,14 +65107,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
@@ -65094,14 +65124,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))) {
@@ -65130,7 +65160,7 @@ var CacheInternal = class {
           key,
           linkedType,
           variables,
-          fields,
+          fields: fieldSelection,
           layer,
           forceNotify
         });
@@ -65180,7 +65210,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);
@@ -65191,7 +65221,7 @@ var CacheInternal = class {
           }
           this.subscriptions.addMany({
             parent: id,
-            selection: fields,
+            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -65216,9 +65246,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") {
@@ -65229,8 +65264,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"
+            );
           }
         }
       }
@@ -65250,9 +65290,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;
@@ -65275,7 +65318,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);
@@ -65285,7 +65328,7 @@ var CacheInternal = class {
         hasData = true;
       } else if (Array.isArray(value)) {
         const listValue = this.hydrateNestedList({
-          fields,
+          fields: fieldSelection,
           variables,
           linkedList: value,
           stepsFromConnection: nextStep
@@ -65300,7 +65343,7 @@ var CacheInternal = class {
       } else {
         const objectFields = this.getSelection({
           parent: value,
-          selection: fields,
+          selection: fieldSelection,
           variables,
           stepsFromConnection: nextStep
         });
@@ -67033,7 +67076,7 @@ var Config = class {
   typeConfig;
   configFile;
   logLevel;
-  disableMasking;
+  defaultFragmentMasking = "enable";
   configIsRoute = null;
   routesDir;
   schemaPollInterval;
@@ -67046,6 +67089,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",
@@ -67062,7 +67110,7 @@ var Config = class {
       defaultKeys,
       types: types15 = {},
       logLevel,
-      disableMasking = false,
+      defaultFragmentMasking = "enable",
       schemaPollInterval = 2e3,
       schemaPollHeaders = {},
       projectDir
@@ -67081,7 +67129,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 = module;
@@ -67093,10 +67145,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 = join2(this.projectRoot, "src", "routes");
     this.schemaPollInterval = schemaPollInterval;
     this.schemaPollHeaders = schemaPollHeaders;
@@ -67290,8 +67342,14 @@ var Config = class {
   pluginDirectory(name2) {
     return houdini_mode.is_testing ? resolve("../../../", name2) : join2(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";
@@ -67303,9 +67361,9 @@ var Config = class {
     return "append";
   }
   get listParentDirective() {
-    return this.listDirectiveParentIDArg;
+    return "parentID";
   }
-  get listDirectiveParentIDArg() {
+  get deprecatedlistDirectiveParentIDArg() {
     return "parentID";
   }
   get listAllListsDirective() {
@@ -67391,7 +67449,7 @@ var Config = class {
       this.listDirective,
       this.listPrependDirective,
       this.listAppendDirective,
-      this.listDirectiveParentIDArg,
+      this.listParentDirective,
       this.listAllListsDirective,
       this.whenDirective,
       this.whenNotDirective,
@@ -67399,7 +67457,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) {
@@ -67963,13 +68023,17 @@ function flattenSelections({
   config: config3,
   filepath,
   selections,
-  fragmentDefinitions
+  fragmentDefinitions,
+  applyFragments,
+  ignoreMaskDisable
 }) {
   const fields = new FieldCollection({
     config: config3,
     filepath,
     selections,
-    fragmentDefinitions
+    fragmentDefinitions,
+    applyFragments,
+    ignoreMaskDisable: !!ignoreMaskDisable
   });
   return fields.toSelectionSet();
 }
@@ -67980,9 +68044,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 = {};
@@ -68011,31 +68079,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];
@@ -68045,9 +68110,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() {
@@ -68063,12 +68139,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
     });
   }
 };
@@ -68423,11 +68517,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 === config3.listDirectiveParentIDArg
-      );
-    }
     if (parentIDArg) {
       if (parentIDArg.value.kind === "StringValue") {
         parentID = parentIDArg.value.value;
@@ -69418,6 +69507,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(
@@ -69444,20 +69535,68 @@ function selection({
         })
       );
     } else if (field.kind === "InlineFragment") {
-      object = deepMerge(
-        filepath,
-        object,
-        selection({
-          config: config3,
+      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: config3,
+            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 = config3.schema.getType(rootType);
+        const typeConditionName = field.typeCondition.name.value;
+        const typeCondition = config3.schema.getType(typeConditionName);
+        const possibleTypes = [];
+        if (!graphql12.isAbstractType(typeCondition)) {
+        } else if (graphql12.isAbstractType(parentType)) {
+          const possibleParentTypes = config3.schema.getPossibleTypes(parentType).map((type) => type.name);
+          for (const possible of config3.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: config3,
+            filepath,
+            rootType: field.typeCondition?.name.value || rootType,
+            operations,
+            selections: field.selectionSet.selections,
+            path: path2,
+            includeFragments,
+            document
+          }).fields
+        };
+      }
     } else if (field.kind === "Field") {
       const type = config3.schema.getType(rootType);
       if (!type) {
@@ -69515,7 +69654,7 @@ function selection({
       }
       if (field.selectionSet) {
         const edgesMark = paginated && document.refetch?.method === "cursor" ? document.refetch.update : markEdges;
-        fieldObj.fields = selection({
+        fieldObj.selection = selection({
           config: config3,
           filepath,
           rootType: typeName,
@@ -69539,11 +69678,49 @@ function selection({
       if (graphql12.isInterfaceType(fieldType) || graphql12.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;
@@ -69678,6 +69855,22 @@ function artifactGenerator(stats) {
             selectionSet = matchingFragment.selectionSet;
           }
           const inputs = operations[0]?.variableDefinitions;
+          const mergedSelection = flattenSelections({
+            config: config3,
+            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,
@@ -69689,7 +69882,7 @@ function artifactGenerator(stats) {
               config: config3,
               filepath: doc.filename,
               rootType,
-              selections: selectionSet.selections,
+              selections: mergedSelection,
               operations: operationsByPath(
                 config3,
                 doc.filename,
@@ -69985,6 +70178,17 @@ function inlineType({
           continue;
         }
         const possibleParents = config3.schema.getPossibleTypes(type).map((t2) => t2.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 config3.schema.getPossibleTypes(fragmentType)) {
           if (!possibleParents.includes(possibleType.name)) {
             continue;
@@ -69992,7 +70196,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);
@@ -70004,12 +70213,7 @@ function inlineType({
       ...(selectedFields || []).filter(
         (field) => field.kind === "Field"
       ).map((selection2) => {
-        const { type: type2, field } = selectionTypeInfo(
-          config3.schema,
-          filepath,
-          rootObj,
-          selection2
-        );
+        const { field } = selectionTypeInfo(config3.schema, filepath, rootObj, selection2);
         const attributeName = selection2.alias?.value || selection2.name.value;
         let attributeType = inlineType({
           config: config3,
@@ -70208,7 +70412,8 @@ async function typescriptGenerator(config3, docs) {
         config: config3,
         filepath: filename,
         selections: definition.selectionSet.selections,
-        fragmentDefinitions
+        fragmentDefinitions,
+        applyFragments: definition.kind === "OperationDefinition"
       });
       if (definition?.kind === "OperationDefinition") {
         await generateOperationTypeDefs(
@@ -70721,14 +70926,12 @@ directive @${config3.paginateDirective}(${config3.paginateNameArg}: String) on F
 """
 	@${config3.listPrependDirective} is used to tell the runtime to add the result to the end of the list
 """
-directive @${config3.listPrependDirective}(
-	${config3.listDirectiveParentIDArg}: ID
-) on FRAGMENT_SPREAD
+directive @${config3.listPrependDirective} on FRAGMENT_SPREAD
 
 """
 	@${config3.listAppendDirective} is used to tell the runtime to add the result to the start of the list
 """
-directive @${config3.listAppendDirective}(${config3.listDirectiveParentIDArg}: ID) on FRAGMENT_SPREAD
+directive @${config3.listAppendDirective} on FRAGMENT_SPREAD
 
 """
 	@${config3.listAllListsDirective} is used to tell the runtime to add the result to all list
@@ -70762,18 +70965,19 @@ directive @${config3.argumentsDirective} on FRAGMENT_DEFINITION
 directive @${config3.cacheDirective}(${config3.cachePolicyArg}: CachePolicy, ${config3.cachePartialArg}: Boolean) on QUERY
 
 """
-	@${config3.houdiniDirective} is used to configure houdini's internal behavior
+	@${config3.manualLoadDirective} is used to disable automatic fetch (no load, no auto fetch in component), you will have to do it manually.
+"""
+directive @${config3.manualLoadDirective} on QUERY
+
+"""
+	@${config3.maskEnableDirective} to enable masking on fragment (overwriting the global conf)
+"""
+directive @${config3.maskEnableDirective} on FRAGMENT_SPREAD
+
+"""
+	@${config3.maskDisableDirective} to disable masking on fragment (overwriting the global conf)
 """
-directive @${config3.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! = ${config3.disableMasking ? "false" : "true"}
-) on QUERY | FRAGMENT_SPREAD
+directive @${config3.maskDisableDirective} on FRAGMENT_SPREAD
 `;
   let currentSchema = graphql21.printSchema(config3.schema);
   if (!currentSchema.includes(`directive @${config3.listDirective}`)) {
@@ -71266,26 +71470,42 @@ async function typeCheck(config3, docs) {
           ),
           targetField.selectionSet
         );
-        const missingIDFields = config3.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: `@${config3.listDirective} can only be applied to types with the necessary id fields: ${missingIDFields.join(
-                  ", "
-                )}.`
-              })
-            );
+        let targetTypes = [type];
+        if (graphql25.isUnionType(type)) {
+          targetTypes = config3.schema.getPossibleTypes(type);
+        } else if (graphql25.isInterfaceType(type)) {
+          try {
+            for (const key of config3.keyFieldsForType(type.name)) {
+              if (!type.getFields()[key]) {
+                throw new Error("continue");
+              }
+            }
+          } catch {
+            targetTypes = config3.schema.getPossibleTypes(type);
+          }
+        }
+        for (const targetType of targetTypes) {
+          const missingIDFields = config3.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: `@${config3.listDirective} can only be applied to types with the necessary id fields: ${missingIDFields.join(
+                    ", "
+                  )}.`
+                })
+              );
+            }
+            return;
           }
-          return;
         }
         lists.push(listName);
         listTypes.push(type.name);
@@ -71315,6 +71535,7 @@ async function typeCheck(config3, docs) {
       fragments
     }),
     checkMutationOperation(config3),
+    checkMaskDirective(config3),
     nodeDirectives(config3, [config3.paginateDirective]),
     knownArguments(config3),
     validateFragmentArguments(config3, filepath, fragments),
@@ -71379,10 +71600,14 @@ var validateLists = ({
       ]);
       if (directive) {
         let parentArg = directive.arguments?.find(
-          (arg) => arg.name.value === config3.listDirectiveParentIDArg
+          (arg) => arg.name.value === config3.deprecatedlistDirectiveParentIDArg
         );
         if (parentArg) {
-          parentIdFound = true;
+          ctx.reportError(
+            new graphql25.GraphQLError(
+              `@${config3.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
+            )
+          );
         }
       }
       if (parentIdFound) {
@@ -71778,6 +72003,28 @@ function checkMutationOperation(config3) {
     };
   };
 }
+function checkMaskDirective(config3) {
+  return function(ctx) {
+    return {
+      FragmentSpread(node, _, __, ___, ancestors) {
+        const maskEnableDirective = node.directives?.find(
+          (c) => c.name.value === config3.maskEnableDirective
+        );
+        const maskDisableDirective = node.directives?.find(
+          (c) => c.name.value === config3.maskDisableDirective
+        );
+        if (maskEnableDirective && maskDisableDirective) {
+          ctx.reportError(
+            new graphql25.GraphQLError(
+              `You can't apply both @${config3.maskEnableDirective} and @${config3.maskDisableDirective} at the same time`
+            )
+          );
+          return;
+        }
+      }
+    };
+  };
+}
 function getAndVerifyNodeInterface(config3) {
   const { schema } = config3;
   const nodeInterface = schema.getType("Node");
@@ -72075,12 +72322,7 @@ async function collectDocuments(config3) {
 }
 async function processJSFile(config3, contents) {
   const documents = [];
-  try {
-    var program = (await parseJS(contents)).script;
-  } catch (e2) {
-    console.log(contents);
-    throw e2;
-  }
+  var program = (await parseJS(contents)).script;
   await find_graphql(config3, program, {
     tag({ tagContent }) {
       documents.push(tagContent);
@@ -72292,8 +72534,11 @@ function HoudiniWatchSchemaPlugin(opts = {}) {
       if (interval <= 0) {
         return;
       }
-      await sleep(interval);
-      await pull(true);
+      async function sleepAndStartPullLoop(interval2) {
+        await sleep(interval2);
+        await pull(true);
+      }
+      sleepAndStartPullLoop(interval);
     },
     buildEnd() {
       go = false;