houdini 0.17.13 → 0.18.0

package/build/cmd-esm/index.js

@@ -5105,7 +5105,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;
@@ -5123,7 +5123,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;
@@ -5178,7 +5178,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)) {
@@ -5213,11 +5213,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;
@@ -5268,7 +5268,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)) {
@@ -5286,7 +5286,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)) {
@@ -5294,11 +5294,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;
@@ -5365,7 +5365,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)) {
@@ -67742,6 +67742,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;
@@ -67964,23 +67978,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"
+                            }
+                          }
+                        }
+                      }
                     }
                   }
                 }
@@ -67996,15 +68019,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"
+                }
+              }
             }
           }
         }
@@ -68064,7 +68092,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
     );
@@ -68553,18 +68581,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
@@ -68577,7 +68607,7 @@ var InMemorySubscriptions = class {
           this.add({
             parent: child,
             spec,
-            selection: fields,
+            selection: innerSelection,
             variables,
             parentType: type
           });
@@ -68588,7 +68618,7 @@ var InMemorySubscriptions = class {
   addFieldSubscription({
     id,
     key,
-    selection: selection2,
+    field,
     spec,
     parentType,
     variables
@@ -68615,8 +68645,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,
@@ -68624,7 +68654,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,
@@ -68641,20 +68671,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) {
@@ -68663,7 +68694,7 @@ var InMemorySubscriptions = class {
           }
           this.addMany({
             parent: linkedRecord,
-            selection: fields,
+            selection: innerSelection,
             variables,
             subscribers,
             parentType: linkedType
@@ -68675,22 +68706,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 || {}]);
         }
       }
     }
@@ -68868,8 +68897,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)
         );
@@ -68877,11 +68907,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);
@@ -68889,7 +68919,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") {
@@ -68909,7 +68939,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);
@@ -68935,14 +68965,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
@@ -68952,14 +68982,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))) {
@@ -68988,7 +69018,7 @@ var CacheInternal = class {
           key,
           linkedType,
           variables,
-          fields,
+          fields: fieldSelection,
           layer,
           forceNotify
         });
@@ -69038,7 +69068,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);
@@ -69049,7 +69079,7 @@ var CacheInternal = class {
           }
           this.subscriptions.addMany({
             parent: id,
-            selection: fields,
+            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -69074,9 +69104,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") {
@@ -69087,8 +69122,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"
+            );
           }
         }
       }
@@ -69108,9 +69148,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;
@@ -69133,7 +69176,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);
@@ -69143,7 +69186,7 @@ var CacheInternal = class {
         hasData = true;
       } else if (Array.isArray(value)) {
         const listValue = this.hydrateNestedList({
-          fields,
+          fields: fieldSelection,
           variables,
           linkedList: value,
           stepsFromConnection: nextStep
@@ -69158,7 +69201,7 @@ var CacheInternal = class {
       } else {
         const objectFields = this.getSelection({
           parent: value,
-          selection: fields,
+          selection: fieldSelection,
           variables,
           stepsFromConnection: nextStep
         });
@@ -70891,7 +70934,7 @@ var Config = class {
   typeConfig;
   configFile;
   logLevel;
-  disableMasking;
+  defaultFragmentMasking = "enable";
   configIsRoute = null;
   routesDir;
   schemaPollInterval;
@@ -70904,6 +70947,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",
@@ -70920,7 +70968,7 @@ var Config = class {
       defaultKeys,
       types: types14 = {},
       logLevel,
-      disableMasking = false,
+      defaultFragmentMasking = "enable",
       schemaPollInterval = 2e3,
       schemaPollHeaders = {},
       projectDir
@@ -70939,7 +70987,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;
@@ -70951,10 +71003,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;
@@ -71148,8 +71200,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";
@@ -71161,9 +71219,9 @@ var Config = class {
     return "append";
   }
   get listParentDirective() {
-    return this.listDirectiveParentIDArg;
+    return "parentID";
   }
-  get listDirectiveParentIDArg() {
+  get deprecatedlistDirectiveParentIDArg() {
     return "parentID";
   }
   get listAllListsDirective() {
@@ -71249,7 +71307,7 @@ var Config = class {
       this.listDirective,
       this.listPrependDirective,
       this.listAppendDirective,
-      this.listDirectiveParentIDArg,
+      this.listParentDirective,
       this.listAllListsDirective,
       this.whenDirective,
       this.whenNotDirective,
@@ -71257,7 +71315,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) {
@@ -71828,13 +71888,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();
 }
@@ -71845,9 +71909,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 = {};
@@ -71876,31 +71944,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];
@@ -71910,9 +71975,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() {
@@ -71928,12 +72004,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
     });
   }
 };
@@ -72288,11 +72382,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;
@@ -73320,6 +73409,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(
@@ -73346,20 +73437,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 (!graphql12.isAbstractType(typeCondition)) {
+        } else if (graphql12.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) {
@@ -73417,7 +73556,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,
@@ -73441,11 +73580,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;
@@ -73580,6 +73757,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,
@@ -73591,7 +73784,7 @@ function artifactGenerator(stats) {
               config: config2,
               filepath: doc.filename,
               rootType,
-              selections: selectionSet.selections,
+              selections: mergedSelection,
               operations: operationsByPath(
                 config2,
                 doc.filename,
@@ -73887,6 +74080,17 @@ function inlineType({
           continue;
         }
         const possibleParents = config2.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 config2.schema.getPossibleTypes(fragmentType)) {
           if (!possibleParents.includes(possibleType.name)) {
             continue;
@@ -73894,7 +74098,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);
@@ -73906,12 +74115,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,
@@ -74110,7 +74314,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(
@@ -74623,14 +74828,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
@@ -74664,18 +74867,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
+
+"""
+	@${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.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.maskDisableDirective} on FRAGMENT_SPREAD
 `;
   let currentSchema = graphql21.printSchema(config2.schema);
   if (!currentSchema.includes(`directive @${config2.listDirective}`)) {
@@ -75168,26 +75372,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 (graphql25.isUnionType(type)) {
+          targetTypes = config2.schema.getPossibleTypes(type);
+        } else if (graphql25.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);
@@ -75217,6 +75437,7 @@ async function typeCheck(config2, docs) {
       fragments
     }),
     checkMutationOperation(config2),
+    checkMaskDirective(config2),
     nodeDirectives(config2, [config2.paginateDirective]),
     knownArguments(config2),
     validateFragmentArguments(config2, filepath, fragments),
@@ -75281,10 +75502,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 graphql25.GraphQLError(
+              `@${config2.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
+            )
+          );
         }
       }
       if (parentIdFound) {
@@ -75680,6 +75905,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 graphql25.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");
@@ -75977,12 +76224,7 @@ async function collectDocuments(config2) {
 }
 async function processJSFile(config2, contents) {
   const documents = [];
-  try {
-    var program3 = (await parseJS(contents)).script;
-  } catch (e2) {
-    console.log(contents);
-    throw e2;
-  }
+  var program3 = (await parseJS(contents)).script;
   await find_graphql(config2, program3, {
     tag({ tagContent }) {
       documents.push(tagContent);
@@ -76282,7 +76524,6 @@ async function init(_path, args) {
   const sourceDir = path_exports.join(targetPath, "src");
   const configPath = path_exports.join(targetPath, "houdini.config.js");
   const houdiniClientPath = typescript ? path_exports.join(sourceDir, "client.ts") : path_exports.join(sourceDir, "client.js");
-  const houdiniClientImport = "./src/client";
   console.log("\u{1F6A7} Generating project files...");
   await updatePackageJSON(targetPath);
   if (is_remote_endpoint) {
@@ -76292,8 +76533,7 @@ async function init(_path, args) {
     configPath,
     schemaPath,
     module,
-    url: is_remote_endpoint ? url : null,
-    houdiniClientImport
+    url: is_remote_endpoint ? url : null
   });
   await fs_exports.writeFile(houdiniClientPath, networkFile(url, typescript));
   await graphqlRCFile(targetPath);
@@ -76350,8 +76590,7 @@ var writeConfigFile = async ({
   configPath,
   schemaPath,
   module,
-  url,
-  houdiniClientImport
+  url
 }) => {
   const config2 = {};
   if (url !== null) {
@@ -76364,9 +76603,7 @@ var writeConfigFile = async ({
     config2.module = module;
   }
   config2.plugins = {
-    "houdini-svelte": {
-      client: houdiniClientImport
-    }
+    "houdini-svelte": {}
   };
   const configObj = JSON.stringify(config2, null, 4);
   const content_base = `/// <references types="houdini-svelte">
@@ -76540,8 +76777,8 @@ async function updatePackageJSON(targetPath) {
   }
   packageJSON.devDependencies = {
     ...packageJSON.devDependencies,
-    houdini: "^0.17.13",
-    "houdini-svelte": "^0.17.13",
+    houdini: "^0.18.0",
+    "houdini-svelte": "^0.18.0",
     graphql: "^15.8.0"
   };
   await fs_exports.writeFile(packagePath, JSON.stringify(packageJSON, null, 4));