houdini 2.0.0-next.9 → 2.0.1

package/build/{runtime-esm/cache/cache.js → runtime/cache/index.js}

@@ -1,15 +1,16 @@
-import { computeKey, PendingValue } from "../lib";
-import { computeID, defaultConfigValues, keyFieldsForType, getCurrentConfig } from "../lib/config";
-import { deepEquals } from "../lib/deepEquals";
-import { flatten } from "../lib/flatten";
-import { getFieldsForType } from "../lib/selection";
-import { fragmentKey } from "../lib/types";
-import { GarbageCollector } from "./gc";
-import { ListManager } from "./lists";
-import { StaleManager } from "./staleManager";
-import { InMemoryStorage } from "./storage";
-import { evaluateKey, rootID } from "./stuff";
-import { InMemorySubscriptions } from "./subscription";
+import { computeID, defaultConfigValues, keyFieldsForType } from "../config.js";
+import { deepEquals } from "../deepEquals.js";
+import { flatten } from "../flatten.js";
+import { computeKey } from "../key.js";
+import { getFieldsForType } from "../selection.js";
+import { PendingValue } from "../types.js";
+import { ArtifactKind, fragmentKey } from "../types.js";
+import { GarbageCollector } from "./gc.js";
+import { ListManager, opaqueListID } from "./lists.js";
+import { StaleManager } from "./staleManager.js";
+import { InMemoryStorage } from "./storage.js";
+import { evaluateKey, rootID } from "./stuff.js";
+import { filterValue, InMemorySubscriptions } from "./subscription.js";
 class Cache {
   // the internal implementation for a lot of the cache's methods are moved into
   // a second class to avoid users from relying on unstable APIs. typescript's private
@@ -44,7 +45,8 @@ class Cache {
     ...args
   }) {
     const layer = layerID ? this._internal_unstable.storage.getLayer(layerID) : this._internal_unstable.storage.topLayer;
-    const subscribers = this._internal_unstable.writeSelection({ ...args, layer }).map((sub) => sub[0]);
+    const toNotify = this._internal_unstable.writeSelection({ ...args, layer });
+    const subscribers = [...toNotify];
     this.#notifySubscribers(subscribers.concat(notifySubscribers));
     return subscribers;
   }
@@ -86,7 +88,7 @@ class Cache {
     const handler = this._internal_unstable.lists.get(name, parentID, allLists, skipMatches);
     if (!handler) {
       throw new Error(
-        `Cannot find list with name: ${name}${parentID ? " under parent " + parentID : ""}. Is it possible that the query is not mounted?`
+        `Cannot find list with name: ${name}${parentID ? ` under parent ${parentID}` : ""}. Is it possible that the query is not mounted?`
       );
     }
     return handler;
@@ -124,6 +126,33 @@ class Cache {
       );
     }
   }
+  // ask every document whose data contains the record(s) to refetch itself.
+  // this includes documents that only contain a record behind a masked
+  // boundary (a fragment spread) thanks to their masked parent subscriptions.
+  // passing several ids notifies each document at most once, even if it
+  // depends on more than one of them (eg a list returned by a mutation).
+  refresh(id) {
+    const ids = Array.isArray(id) ? id : [id];
+    const notified = /* @__PURE__ */ new Set();
+    for (const baseID of ids) {
+      const recordIDs = [this._internal_unstable.storage.idMaps[baseID], baseID].filter(
+        Boolean
+      );
+      for (const recordID of recordIDs) {
+        for (const [spec] of this._internal_unstable.subscriptions.getAll(recordID, {
+          includeMaskedParents: true
+        })) {
+          if (spec.kind === ArtifactKind.Subscription) {
+            continue;
+          }
+          if (!notified.has(spec.onMessage)) {
+            notified.add(spec.onMessage);
+            spec.onMessage({ kind: "refetch" });
+          }
+        }
+      }
+    }
+  }
   markRecordStale(id, options) {
     if (options.field) {
       const key = computeKey({ field: options.field, args: options.when ?? {} });
@@ -147,14 +176,18 @@ class Cache {
   clearLayer(layerID) {
     const layer = this._internal_unstable.storage.getLayer(layerID);
     if (!layer) {
-      throw new Error("Cannot find layer with id: " + layerID);
+      throw new Error(`Cannot find layer with id: ${layerID}`);
     }
     const toNotify = [];
     const allFields = [];
     for (const target of [layer.fields, layer.links]) {
       for (const [id, fields] of Object.entries(target)) {
         allFields.push(
-          ...Object.entries(fields).map(([field, value]) => ({ id, field, value }))
+          ...Object.entries(fields).map(([field, value]) => ({
+            id,
+            field,
+            value
+          }))
         );
       }
     }
@@ -198,22 +231,29 @@ class Cache {
     this._internal_unstable.storage.reset();
     this.#notifySubscribers(subSpecs);
   }
+  // returns the current notification generation; fragment references carry this value
+  // so hooks can detect which epoch of data they were rendered with
+  getEpoch() {
+    return this._internal_unstable.epoch;
+  }
   #notifySubscribers(subs) {
     if (subs.length === 0) {
       return;
     }
-    const notified = [];
+    this._internal_unstable.epoch++;
+    const notified = /* @__PURE__ */ new Set();
     for (const spec of subs) {
-      if (!notified.includes(spec.set)) {
-        notified.push(spec.set);
-        spec.set(
-          this._internal_unstable.getSelection({
+      if (!notified.has(spec.onMessage)) {
+        notified.add(spec.onMessage);
+        spec.onMessage({
+          kind: "update",
+          data: this._internal_unstable.getSelection({
             parent: spec.parentID || rootID,
             selection: spec.selection,
             variables: spec.variables?.() || {},
             ignoreMasking: false
           }).data
-        );
+        });
       }
     }
   }
@@ -221,6 +261,9 @@ class Cache {
 class CacheInternal {
   // for server-side requests we need to be able to flag the cache as disabled so we dont write to it
   disabled = false;
+  // monotonically increasing counter incremented on every cache notification flush;
+  // threaded into fragment references so hooks know which generation of data they hold
+  epoch = 0;
   _config;
   storage;
   subscriptions;
@@ -260,7 +303,7 @@ class CacheInternal {
     }
   }
   get config() {
-    return this._config ?? getCurrentConfig();
+    return this._config ?? {};
   }
   setConfig(config) {
     this._config = config;
@@ -272,19 +315,19 @@ class CacheInternal {
     parent = rootID,
     applyUpdates,
     layer,
-    toNotify = [],
+    toNotify = /* @__PURE__ */ new Set(),
     forceNotify,
     forceStale
   }) {
     if (this.disabled) {
-      return [];
+      return toNotify;
     }
-    let targetSelection = getFieldsForType(
+    const targetSelection = getFieldsForType(
       selection,
-      data["__typename"],
+      data.__typename,
       false
     );
-    for (const [field, value] of Object.entries(data)) {
+    for (let [field, value] of Object.entries(data)) {
       if (!selection || !targetSelection[field]) {
         continue;
       }
@@ -297,11 +340,12 @@ class CacheInternal {
         updates
       } = targetSelection[field];
       const key = evaluateKey(keyRaw, variables);
-      if (value && typeof value === "object" && "__typename" in value && value["__typename"]) {
-        linkedType = value["__typename"];
+      if (value && typeof value === "object" && "__typename" in value && value.__typename) {
+        linkedType = value.__typename;
       }
       const currentSubscribers = this.subscriptions.get(parent, key);
-      const specs = currentSubscribers.map((sub) => sub[0]);
+      const maskedParentSubscribers = this.subscriptions.getMaskedParents(parent, key);
+      const specs = currentSubscribers.map((sub) => sub[0]).concat(maskedParentSubscribers.map((sub) => sub[0]));
       const { value: previousValue, displayLayers } = this.storage.get(parent, key);
       const displayLayer = layer.isDisplayLayer(displayLayers);
       if (displayLayer) {
@@ -326,16 +370,17 @@ class CacheInternal {
             }
           }
         }
-        if (updates && applyUpdates?.includes("prepend") && ["endCursor", "hasNextPage"].includes(key)) {
-          newValue = previousValue;
-        } else if (updates && applyUpdates?.includes("append") && ["startCursor", "hasPreviousPage"].includes(key)) {
+        if (updates && applyUpdates?.some((op) => !updates.includes(op))) {
           newValue = previousValue;
         }
         const valueChanged = !deepEquals(newValue, previousValue);
         if (displayLayer && (valueChanged || forceNotify)) {
-          toNotify.push(...currentSubscribers);
+          for (const [sub] of currentSubscribers) toNotify.add(sub);
         }
         layer.writeField(parent, key, newValue);
+        if (key === "__typename" && typeof newValue === "string") {
+          this.storage.typenames.set(parent, newValue);
+        }
       } else if (value === null) {
         if (previousValue === null) {
           continue;
@@ -345,8 +390,9 @@ class CacheInternal {
           this.subscriptions.remove(link, fieldSelection, specs, variables);
         }
         layer.writeLink(parent, key, null);
-        toNotify.push(...currentSubscribers);
+        for (const [sub] of currentSubscribers) toNotify.add(sub);
       } else if (value instanceof Object && !Array.isArray(value)) {
+        value = value;
         if (isAbstract) {
           if (!value.__typename) {
             throw new Error(
@@ -358,7 +404,7 @@ class CacheInternal {
         if (value !== null) {
           linkedID = !this.isEmbedded(linkedType, value) ? this.id(linkedType, value) : `${parent}.${key}`;
         }
-        let linkChange = linkedID !== previousValue;
+        const linkChange = linkedID !== previousValue;
         layer.writeLink(parent, key, linkedID);
         if (linkedID && displayLayer && (linkChange || forceNotify)) {
           if (previousValue && typeof previousValue === "string") {
@@ -370,7 +416,16 @@ class CacheInternal {
             variables,
             parentType: linkedType
           });
-          toNotify.push(...currentSubscribers);
+          if (maskedParentSubscribers.length > 0) {
+            this.subscriptions.addMany({
+              parent: linkedID,
+              subscribers: maskedParentSubscribers,
+              variables,
+              parentType: linkedType,
+              masked: true
+            });
+          }
+          for (const [sub] of currentSubscribers) toNotify.add(sub);
         }
         if (linkedID) {
           this.writeSelection({
@@ -386,7 +441,7 @@ class CacheInternal {
         }
       } else if (Array.isArray(value) && // make typescript happy
       (typeof previousValue === "undefined" || previousValue === null || Array.isArray(previousValue))) {
-        let oldIDs = [...previousValue || []];
+        let oldIDs = [...Array.isArray(previousValue) ? previousValue : []];
         if (updates?.includes("append") || updates?.includes("prepend")) {
           oldIDs = oldIDs.filter((id) => {
             for (const layer2 of this.storage.data) {
@@ -403,6 +458,11 @@ class CacheInternal {
           });
         }
         let linkedIDs = [];
+        const insertingUpdates = Boolean(
+          applyUpdates?.some(
+            (update) => update !== "replace" && updates?.includes(update)
+          )
+        );
         const { newIDs, nestedIDs } = this.extractNestedListIDs({
           value,
           abstract: Boolean(isAbstract),
@@ -414,7 +474,8 @@ class CacheInternal {
           variables,
           fields: fieldSelection,
           layer,
-          forceNotify
+          forceNotify,
+          previousIDs: !insertingUpdates && Array.isArray(previousValue) ? previousValue : null
         });
         let action = () => {
           layer.writeLink(parent, key, linkedIDs);
@@ -488,19 +549,28 @@ class CacheInternal {
         }
         const contentChanged = !deepEquals(linkedIDs, oldIDs) || previousValue === null;
         if (contentChanged || forceNotify) {
-          toNotify.push(...currentSubscribers);
+          for (const [sub] of currentSubscribers) toNotify.add(sub);
         }
+        const linkedIDSet = new Set(
+          linkedIDs.flat(Infinity)
+        );
         for (const lostID of oldIDs) {
-          if (linkedIDs.includes(lostID) || !lostID) {
+          if (!lostID || linkedIDSet.has(lostID)) {
             continue;
           }
           this.subscriptions.remove(lostID, fieldSelection, specs, variables);
+          if (!layer.optimistic && typeof lostID === "string" && lostID.startsWith(`${parent}.${key}[`)) {
+            this.storage.removeEmbeddedRecord(lostID);
+            this.lifetimes.delete(lostID);
+            this.staleManager.deleteRecord(lostID);
+          }
         }
         if (contentChanged || oldIDs.length === 0 && newIDs.length === 0) {
           action();
         }
-        for (const id of newIDs.filter((id2) => !oldIDs.includes(id2))) {
-          if (id == null) {
+        const oldIDSet = new Set(oldIDs);
+        for (const id of newIDs) {
+          if (id == null || oldIDSet.has(id)) {
             continue;
           }
           this.subscriptions.addMany({
@@ -509,6 +579,15 @@ class CacheInternal {
             variables,
             parentType: linkedType
           });
+          if (maskedParentSubscribers.length > 0) {
+            this.subscriptions.addMany({
+              parent: id,
+              subscribers: maskedParentSubscribers,
+              variables,
+              parentType: linkedType,
+              masked: true
+            });
+          }
         }
       }
       const processedOperations = /* @__PURE__ */ new Set();
@@ -516,27 +595,43 @@ class CacheInternal {
         let parentID;
         if (operation.parentID) {
           if (operation.parentID.kind !== "Variable") {
-            parentID = operation.parentID.value;
+            parentID = "value" in operation.parentID ? String(operation.parentID.value) : void 0;
           } else {
-            const id = variables[operation.parentID.value];
+            const varName = operation.parentID.name.value;
+            const id = variables[varName];
             if (typeof id !== "string") {
               throw new Error("parentID value must be a string");
             }
             parentID = id;
           }
         }
-        if (operation.list && !this.lists.get(operation.list, parentID, operation.target === "all")) {
-          continue;
+        let opaqueListID2;
+        if (operation.listID) {
+          if (operation.listID.kind !== "Variable") {
+            opaqueListID2 = "value" in operation.listID ? String(operation.listID.value) : void 0;
+          } else {
+            const varName = operation.listID.name.value;
+            const id = variables[varName];
+            if (typeof id !== "string") {
+              throw new Error("listID value must be a string");
+            }
+            opaqueListID2 = id;
+          }
+        }
+        if (operation.list) {
+          const exists = opaqueListID2 ? this.lists.getByOpaqueID(opaqueListID2) : this.lists.get(operation.list, parentID, operation.target === "all");
+          if (!exists) continue;
         }
         const targets = Array.isArray(value) ? value : [value];
         for (const target of targets) {
           if (operation.action === "insert" && target instanceof Object && fieldSelection && operation.list) {
-            this.cache.list(
+            const insertList = opaqueListID2 ? this.lists.getByOpaqueID(opaqueListID2, processedOperations) : this.cache.list(
               operation.list,
               parentID,
               operation.target === "all",
               processedOperations
-            ).when(operation.when).addToList(
+            );
+            insertList.when(resolveWhen(operation.when, variables)).addToList(
               fieldSelection,
               target,
               variables,
@@ -544,42 +639,54 @@ class CacheInternal {
               layer
             );
           } else if (operation.action === "toggle" && target instanceof Object && fieldSelection && operation.list) {
-            this.cache.list(
+            const toggleList = opaqueListID2 ? this.lists.getByOpaqueID(opaqueListID2, processedOperations) : this.cache.list(
               operation.list,
               parentID,
               operation.target === "all",
               processedOperations
-            ).when(operation.when).toggleElement({
+            );
+            toggleList.when(resolveWhen(operation.when, variables)).toggleElement({
               selection: fieldSelection,
               data: target,
               variables,
               where: operation.position || "last",
               layer
             });
+          } else if (operation.action === "upsert" && target instanceof Object && fieldSelection && operation.list) {
+            const upsertList = opaqueListID2 ? this.lists.getByOpaqueID(opaqueListID2, processedOperations) : this.cache.list(
+              operation.list,
+              parentID,
+              operation.target === "all",
+              processedOperations
+            );
+            upsertList.when(operation.when).upsertInList(
+              fieldSelection,
+              target,
+              variables,
+              operation.position || "last",
+              layer
+            );
           } else if (operation.action === "remove" && target instanceof Object && fieldSelection && operation.list) {
-            this.cache.list(
+            const removeList = opaqueListID2 ? this.lists.getByOpaqueID(opaqueListID2, processedOperations) : this.cache.list(
               operation.list,
               parentID,
               operation.target === "all",
               processedOperations
-            ).when(operation.when).remove(target, variables, layer);
+            );
+            removeList.when(resolveWhen(operation.when, variables)).remove(target, variables, layer);
           } else if (operation.action === "delete" && operation.type && target) {
             const targetID = this.id(operation.type, target);
             if (!targetID) {
               continue;
             }
-            toNotify.push(
-              ...this.subscriptions.getAll(targetID).filter((sub) => sub[0].parentID !== targetID)
-            );
+            for (const [sub] of this.subscriptions.getAll(targetID).filter((sub2) => sub2[0].parentID !== targetID)) {
+              toNotify.add(sub);
+            }
             this.cache.delete(targetID, layer);
           }
         }
         if (operation.list) {
-          const matchingLists = this.cache.list(
-            operation.list,
-            parentID,
-            operation.target === "all"
-          );
+          const matchingLists = opaqueListID2 ? this.lists.getByOpaqueID(opaqueListID2) : this.cache.list(operation.list, parentID, operation.target === "all");
           for (const list of matchingLists.lists) {
             processedOperations.add(list.fieldRef);
           }
@@ -620,8 +727,8 @@ class CacheInternal {
     let partial = false;
     let cascadeNull = false;
     let stale = false;
-    const typename = this.storage.get(parent, "__typename").value;
-    let targetSelection = getFieldsForType(selection, typename, !!generateLoading);
+    const typename = this.storage.getTypename(parent);
+    const targetSelection = getFieldsForType(selection, typename, !!generateLoading);
     for (const [
       attributeName,
       {
@@ -644,7 +751,7 @@ class CacheInternal {
         return d.name === "include";
       });
       if (includeDirective) {
-        if (!evaluateVariables(includeDirective.arguments, variables ?? {})["if"]) {
+        if (!evaluateVariables(includeDirective.arguments, variables ?? {}).if) {
           continue;
         }
       }
@@ -652,7 +759,7 @@ class CacheInternal {
         return d.name === "skip";
       });
       if (skipDirective) {
-        if (evaluateVariables(skipDirective.arguments, variables ?? {})["if"]) {
+        if (evaluateVariables(skipDirective.arguments, variables ?? {}).if) {
           continue;
         }
       }
@@ -757,6 +864,10 @@ class CacheInternal {
           hasData = true;
         }
       }
+      if (list?.includeListID && fieldTarget[attributeName] != null) {
+        ;
+        fieldTarget[attributeName].__id = opaqueListID(parent, list.name);
+      }
       if (generateLoading && fieldLoading?.list) {
         fieldTarget[attributeName] = wrapInLists(
           Array.from({ length: fieldLoading.list.count }).fill(
@@ -792,7 +903,7 @@ class CacheInternal {
     if (!type) {
       return id;
     }
-    return type + ":" + id;
+    return `${type}:${id}`;
   }
   // the list of fields that we need in order to compute an objects id
   idFields(type) {
@@ -894,12 +1005,14 @@ class CacheInternal {
     applyUpdates,
     specs,
     layer,
-    forceNotify
+    forceNotify,
+    previousIDs
   }) {
     const nestedIDs = [];
     const newIDs = [];
     for (const [i, entry] of value.entries()) {
       if (Array.isArray(entry)) {
+        const previousEntry = previousIDs?.[i];
         const inner = this.extractNestedListIDs({
           value: entry,
           abstract,
@@ -911,7 +1024,8 @@ class CacheInternal {
           applyUpdates,
           specs,
           layer,
-          forceNotify
+          forceNotify,
+          previousIDs: Array.isArray(previousEntry) ? previousEntry : null
         });
         newIDs.push(...inner.newIDs);
         nestedIDs[i] = inner.nestedIDs;
@@ -923,7 +1037,8 @@ class CacheInternal {
         continue;
       }
       const entryObj = entry;
-      let linkedID = `${recordID}.${key}[${this.storage.nextRank}]`;
+      const previousID = previousIDs?.[i];
+      let linkedID = typeof previousID === "string" && previousID.startsWith(`${recordID}.${key}[`) ? previousID : `${recordID}.${key}[${this.storage.nextRank}]`;
       let innerType = linkedType;
       const typename = entryObj.__typename;
       if (typename) {
@@ -1008,6 +1123,18 @@ function variableValue(value, args) {
     );
   }
 }
+function resolveWhen(when, variables) {
+  if (!when) {
+    return void 0;
+  }
+  const resolve = (conditions) => Object.fromEntries(
+    Object.entries(conditions).map(([key, value]) => [key, filterValue(value, variables)])
+  );
+  return {
+    ...when.must ? { must: resolve(when.must) } : {},
+    ...when.must_not ? { must_not: resolve(when.must_not) } : {}
+  };
+}
 function fragmentReference({
   component,
   prop

package/build/runtime/cache/lists.d.ts

@@ -1,13 +1,16 @@
-import type { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../lib/types';
-import type { Cache } from './cache';
-import type { Layer } from './storage';
+import type { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../types.js';
+import type { Cache } from './index.js';
+import type { Layer } from './storage.js';
+export declare function opaqueListID(parentID: string, listName: string): string;
 export declare class ListManager {
     rootID: string;
     cache: Cache;
     constructor(cache: Cache, rootID: string);
     lists: Map<string, Map<string, ListCollection>>;
     private listsByField;
+    private listsByOpaqueID;
     get(listName: string, id?: string, allLists?: boolean, skipMatches?: Set<string>): ListCollection | null;
+    getByOpaqueID(opaqueID: string, skipMatches?: Set<string>): ListCollection | null;
     getLists(listName: string, id?: string, allLists?: boolean): ListCollection | null | undefined;
     remove(listName: string, id: string): void;
     add(list: {
@@ -38,7 +41,7 @@ export declare class List {
     readonly name: string;
     private connection;
     private manager;
-    private abstract?;
+    abstract?: boolean;
     constructor({ name, recordID, recordType, key, listType, selection, when, filters, connection, manager, abstract, }: Parameters<ListManager['add']>[0] & {
         manager: ListManager;
     });
@@ -70,6 +73,7 @@ export declare class List {
         layer?: Layer;
         where: 'first' | 'last';
     }): void;
+    upsertInList(selection: SubscriptionSelection, data: {}, variables: {} | undefined, where: 'first' | 'last', layer?: Layer): void;
     [Symbol.iterator](): Generator<string, void, unknown>;
 }
 export declare class ListCollection {
@@ -82,6 +86,7 @@ export declare class ListCollection {
     removeID(...args: Parameters<List['removeID']>): boolean;
     remove(...args: Parameters<List['remove']>): void;
     toggleElement(...args: Parameters<List['toggleElement']>): void;
+    upsertInList(...args: Parameters<List['upsertInList']>): void;
     when(when?: ListWhen): ListCollection;
     includes(key: string): boolean;
     deleteListWithKey(key: string): List[];