houdini 2.0.0-next.8 → 2.0.0

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

@@ -1,5 +1,9 @@
-import { flatten } from "../lib/flatten";
-import { rootID } from "./stuff";
+import { deepEquals } from "../deepEquals.js";
+import { flatten } from "../flatten.js";
+import { rootID } from "./stuff.js";
+function opaqueListID(parentID, listName) {
+  return `${parentID}::${listName}`;
+}
 class ListManager {
   rootID;
   cache;
@@ -10,6 +14,8 @@ class ListManager {
   // associate list names with the handler that wraps the list
   lists = /* @__PURE__ */ new Map();
   listsByField = /* @__PURE__ */ new Map();
+  // indexed by the opaque list ID exposed as __id
+  listsByOpaqueID = /* @__PURE__ */ new Map();
   get(listName, id, allLists, skipMatches) {
     const lists = this.getLists(listName, id, allLists);
     if (!lists) {
@@ -21,6 +27,17 @@ class ListManager {
       return lists;
     }
   }
+  // look up a list by the opaque ID that was attached as __id
+  getByOpaqueID(opaqueID, skipMatches) {
+    const collection = this.listsByOpaqueID.get(opaqueID);
+    if (!collection) return null;
+    if (skipMatches) {
+      return new ListCollection(
+        collection.lists.filter((list) => !skipMatches.has(list.fieldRef))
+      );
+    }
+    return collection;
+  }
   getLists(listName, id, allLists) {
     const matches = this.lists.get(listName);
     if (!matches || matches.size === 0) {
@@ -28,7 +45,7 @@ class ListManager {
     }
     if (allLists) {
       return new ListCollection(
-        Array.from(matches, ([key, value]) => [...value.lists]).flat()
+        Array.from(matches, ([_key, value]) => [...value.lists]).flat()
       );
     }
     const head = [...matches.values()][0];
@@ -42,14 +59,16 @@ class ListManager {
     }
     if (!id) {
       console.error(
-        `Found multiple instances of "${listName}". Please provide one of @parentID or @allLists directives to help identify which list you want modify. For more information, visit this guide: https://www.houdinigraphql.com/api/graphql#parentidvalue-string `
+        `Found multiple instances of "${listName}". Please provide one of @parentID, @listID, or @allLists directives to help identify which list you want modify. For more information, visit this guide: https://www.houdinigraphql.com/api/graphql#parentidvalue-string `
       );
       return null;
     }
     return this.lists.get(listName)?.get(parentID);
   }
   remove(listName, id) {
-    this.lists.get(listName)?.delete(id || this.rootID);
+    const parentID = id || this.rootID;
+    this.lists.get(listName)?.delete(parentID);
+    this.listsByOpaqueID.delete(opaqueListID(parentID, listName));
   }
   add(list) {
     if (!this.lists.has(list.name)) {
@@ -75,6 +94,7 @@ class ListManager {
     const handler = new List({ ...list, manager: this });
     this.lists.get(list.name).get(parentID).lists.push(handler);
     this.listsByField.get(parentID).get(list.key).push(handler);
+    this.listsByOpaqueID.set(opaqueListID(parentID, name), this.lists.get(name).get(parentID));
   }
   removeIDFromAllLists(id, layer) {
     let removed = false;
@@ -95,6 +115,7 @@ class ListManager {
       this.lists.get(list.name)?.get(list.recordID)?.deleteListWithKey(field);
       if (this.lists.get(list.name)?.get(list.recordID)?.lists.length === 0) {
         this.lists.get(list.name)?.delete(list.recordID);
+        this.listsByOpaqueID.delete(opaqueListID(list.recordID, list.name));
       }
     }
     this.listsByField.get(parentID).delete(field);
@@ -102,6 +123,7 @@ class ListManager {
   reset() {
     this.lists.clear();
     this.listsByField.clear();
+    this.listsByOpaqueID.clear();
   }
 }
 class List {
@@ -219,7 +241,7 @@ class List {
         newEntry: {
           edges: [
             {
-              __typename: listType + "Edge",
+              __typename: `${listType}Edge`,
               node: {
                 ...data,
                 __typename: listType
@@ -297,29 +319,40 @@ class List {
       parentID = embeddedConnectionID;
       targetKey = "edges";
     }
-    let value = this.cache._internal_unstable.storage.get(parentID, targetKey).value;
-    if (!value || !value.includes(targetID)) {
+    const value = this.cache._internal_unstable.storage.get(parentID, targetKey).value;
+    if (!value?.includes(targetID)) {
       return;
     }
     const subscribers = this.cache._internal_unstable.subscriptions.get(this.recordID, this.key);
+    const maskedParentSubscribers = this.cache._internal_unstable.subscriptions.getMaskedParents(this.recordID, this.key);
+    const targetSelection = this.connection ? this.selection.fields.edges.selection : this.selection;
     this.cache._internal_unstable.subscriptions.remove(
       targetID,
-      // if we are unsubscribing from a connection, the fields we care about
-      // are tucked away under edges
-      this.connection ? this.selection.fields.edges.selection : this.selection,
+      targetSelection,
       subscribers.map((sub) => sub[0]),
       variables
     );
+    if (maskedParentSubscribers.length > 0) {
+      this.cache._internal_unstable.subscriptions.remove(
+        targetID,
+        targetSelection,
+        maskedParentSubscribers.map((sub) => sub[0]),
+        variables,
+        [],
+        true
+      );
+    }
     this.cache._internal_unstable.storage.remove(parentID, targetKey, targetID, layer);
     for (const [spec] of subscribers) {
-      spec.set(
-        this.cache._internal_unstable.getSelection({
+      spec.onMessage({
+        kind: "update",
+        data: this.cache._internal_unstable.getSelection({
           parent: spec.parentID || this.manager.rootID,
           selection: spec.selection,
           variables: spec.variables?.() || {},
           ignoreMasking: false
         }).data
-      );
+      });
     }
     return true;
   }
@@ -334,19 +367,19 @@ class List {
     return data.__typename || this.type;
   }
   validateWhen(when) {
-    let filters = when || this._when;
+    const filters = when || this._when;
     let ok = true;
     if (filters) {
       const targets = this.filters;
       if (filters.must && targets) {
         ok = Object.entries(filters.must).reduce(
-          (prev, [key, value]) => Boolean(prev && targets[key] == value),
+          (prev, [key, value]) => Boolean(prev && deepEquals(targets[key], value)),
           ok
         );
       }
       if (filters.must_not) {
         ok = !targets || Object.entries(filters.must_not).reduce(
-          (prev, [key, value]) => Boolean(prev && targets[key] != value),
+          (prev, [key, value]) => Boolean(prev && !deepEquals(targets[key], value)),
           ok
         );
       }
@@ -364,17 +397,56 @@ class List {
       this.addToList(selection, data, variables, where, layer);
     }
   }
+  upsertInList(selection, data, variables = {}, where, layer) {
+    const listType = this.listType(data);
+    const dataID = this.cache._internal_unstable.id(listType, data);
+    if (!this.validateWhen() || !dataID) {
+      return;
+    }
+    let isInList = false;
+    if (this.connection) {
+      const { value: embeddedConnection } = this.cache._internal_unstable.storage.get(
+        this.recordID,
+        this.key
+      );
+      if (embeddedConnection) {
+        const { value: edges } = this.cache._internal_unstable.storage.get(
+          embeddedConnection,
+          "edges"
+        );
+        for (const edge of flatten(edges) || []) {
+          if (!edge) continue;
+          const { value: nodeID } = this.cache._internal_unstable.storage.get(
+            edge,
+            "node"
+          );
+          if (nodeID === dataID) {
+            isInList = true;
+            break;
+          }
+        }
+      }
+    } else {
+      const { value } = this.cache._internal_unstable.storage.get(this.recordID, this.key);
+      isInList = !!value?.includes(dataID);
+    }
+    if (isInList) {
+      this.cache.write({ selection, data, variables, layer: layer?.id });
+    } else {
+      this.addToList(selection, data, variables, where, layer);
+    }
+  }
   // iterating over the list handler should be the same as iterating over
   // the underlying linked list
   *[Symbol.iterator]() {
     let entries = [];
-    let value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
+    const value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
     if (!this.connection) {
       entries = flatten(value);
     } else {
       entries = this.cache._internal_unstable.storage.get(value, "edges").value;
     }
-    for (let record of entries) {
+    for (const record of entries) {
       yield record;
     }
   }
@@ -388,13 +460,19 @@ class ListCollection {
     return this.lists[0].selection;
   }
   append(...args) {
-    this.lists.forEach((list) => list.append(...args));
+    this.lists.forEach((list) => {
+      list.append(...args);
+    });
   }
   prepend(...args) {
-    this.lists.forEach((list) => list.prepend(...args));
+    this.lists.forEach((list) => {
+      list.prepend(...args);
+    });
   }
   addToList(...args) {
-    this.lists.forEach((list) => list.addToList(...args));
+    this.lists.forEach((list) => {
+      list.addToList(...args);
+    });
   }
   removeID(...args) {
     let removed = false;
@@ -406,10 +484,19 @@ class ListCollection {
     return removed;
   }
   remove(...args) {
-    this.lists.forEach((list) => list.remove(...args));
+    this.lists.forEach((list) => {
+      list.remove(...args);
+    });
   }
   toggleElement(...args) {
-    this.lists.forEach((list) => list.toggleElement(...args));
+    this.lists.forEach((list) => {
+      list.toggleElement(...args);
+    });
+  }
+  upsertInList(...args) {
+    this.lists.forEach((list) => {
+      list.upsertInList(...args);
+    });
   }
   when(when) {
     return new ListCollection(
@@ -422,12 +509,13 @@ class ListCollection {
     return !!this.lists.find((list) => list.key === key);
   }
   deleteListWithKey(key) {
-    return this.lists = this.lists.filter((list) => list.key !== key);
+    this.lists = this.lists.filter((list) => list.key !== key);
+    return this.lists;
   }
   // iterating over the collection should be the same as iterating over
   // the underlying list
   *[Symbol.iterator]() {
-    for (let list of this.lists) {
+    for (const list of this.lists) {
       for (const entry of list) {
         yield entry;
       }
@@ -437,5 +525,6 @@ class ListCollection {
 export {
   List,
   ListCollection,
-  ListManager
+  ListManager,
+  opaqueListID
 };

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

@@ -1,4 +1,4 @@
-import type { Cache } from './cache';
+import type { Cache } from './index.js';
 export declare class StaleManager {
     #private;
     cache: Cache;
@@ -26,6 +26,7 @@ export declare class StaleManager {
     markRecordStale(id: string): void;
     markTypeStale(type: string): void;
     markTypeFieldStale(type: string, field: string, when?: {}): void;
+    deleteRecord(id: string): void;
     delete(id: string, field: string): void;
     reset(): void;
 }

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

@@ -1,4 +1,4 @@
-import { computeKey } from "../lib";
+import { computeKey } from "../key.js";
 class StaleManager {
   cache;
   // 	id {         "User:1"    "_ROOT_"
@@ -34,7 +34,7 @@ class StaleManager {
    */
   setFieldTimeToNow(id, field) {
     this.#initMapId(id);
-    this.fieldsTime.get(id)?.set(field, (/* @__PURE__ */ new Date()).valueOf());
+    this.fieldsTime.get(id)?.set(field, Date.now());
   }
   /**
    * set null to a field (stale)
@@ -81,6 +81,10 @@ class StaleManager {
       }
     }
   }
+  // remove every entry associated with a record
+  deleteRecord(id) {
+    this.fieldsTime.delete(id);
+  }
   // clean up the stale manager
   delete(id, field) {
     if (this.fieldsTime.has(id)) {

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

@@ -1,9 +1,10 @@
-import type { GraphQLValue } from '../lib/types';
+import type { GraphQLValue } from '../types.js';
 export declare class InMemoryStorage {
     data: Layer[];
     private idCount;
     private rank;
     idMaps: Record<string, string>;
+    typenames: Map<string, string>;
     constructor();
     get layerCount(): number;
     get nextRank(): number;
@@ -13,6 +14,7 @@ export declare class InMemoryStorage {
     remove(id: string, field: string, target: string, layer?: Layer): void;
     delete(id: string, layer?: Layer): void;
     deleteField(id: string, field: string): void;
+    removeEmbeddedRecord(id: string): void;
     getLayer(id: number): Layer;
     replaceID(replacement: {
         from: string;
@@ -32,7 +34,8 @@ export declare class InMemoryStorage {
         rank: number;
         fields: EntityFieldMap;
         links: LinkMap;
-    }, layer?: Layer): void;
+    }, layer?: Layer): Layer | undefined;
+    getTypename(id: string): string | undefined;
     reset(): void;
 }
 export declare class Layer {

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

@@ -1,9 +1,11 @@
-import { flatten } from "../lib/flatten";
+import { flatten } from "../flatten.js";
 class InMemoryStorage {
   data;
   idCount = 1;
   rank = 0;
   idMaps = {};
+  // fast lookup: record id → __typename, maintained alongside normal field writes
+  typenames = /* @__PURE__ */ new Map();
   constructor() {
     this.data = [];
   }
@@ -36,50 +38,66 @@ class InMemoryStorage {
   deleteField(id, field) {
     return this.topLayer.deleteField(id, field);
   }
+  // embedded records are only ever referenced by the field that wrote them so once
+  // that reference is gone the data can be physically removed. any embedded
+  // descendants are left for the garbage collector
+  removeEmbeddedRecord(id) {
+    for (const layer of this.data) {
+      if (layer.optimistic) {
+        continue;
+      }
+      delete layer.fields[id];
+      delete layer.links[id];
+    }
+    this.typenames.delete(id);
+  }
   getLayer(id) {
     for (const layer of this.data) {
       if (layer.id === id) {
         return layer;
       }
     }
-    throw new Error("Could not find layer with id: " + id);
+    throw new Error(`Could not find layer with id: ${id}`);
   }
   replaceID(replacement) {
     for (const layer of this.data) {
       layer.replaceID(replacement);
     }
+    const typename = this.typenames.get(replacement.from);
+    if (typename) this.typenames.set(replacement.to, typename);
   }
   get(targetID, field, defaultValue) {
-    const operations = {
-      [OperationKind.insert]: {
-        [OperationLocation.start]: [],
-        [OperationLocation.end]: []
-      },
-      [OperationKind.remove]: /* @__PURE__ */ new Set()
-    };
-    const layerIDs = [];
-    const recordIDs = [this.idMaps[targetID], targetID].filter(Boolean);
+    let insertStart;
+    let insertEnd;
+    let removeSet;
+    let layerIDs;
+    const mappedID = this.idMaps[targetID];
+    const recordIDs = mappedID ? [mappedID, targetID] : [targetID];
     for (let i = this.data.length - 1; i >= 0; i--) {
       for (const id of recordIDs) {
         const layer = this.data[i];
         let [layerValue, kind] = layer.get(id, field);
-        const layerOperations = layer.getOperations(id, field) || [];
-        layer.deletedIDs.forEach((v) => {
-          if (layer.operations[v]?.undoDeletesInList?.includes(field)) {
-            return;
-          }
-          operations.remove.add(v);
-          if (this.idMaps[v]) {
-            operations.remove.add(this.idMaps[v]);
-          }
-        });
+        const layerOperations = layer.getOperations(id, field);
+        if (layer.deletedIDs.size > 0) {
+          layer.deletedIDs.forEach((v) => {
+            if (layer.operations[v]?.undoDeletesInList?.includes(field)) {
+              return;
+            }
+            if (!removeSet) removeSet = /* @__PURE__ */ new Set();
+            removeSet.add(v);
+            if (this.idMaps[v]) {
+              removeSet.add(this.idMaps[v]);
+            }
+          });
+        }
         if (typeof layerValue === "undefined" && defaultValue) {
           const targetLayer = this.topLayer;
           targetLayer.writeField(id, field, defaultValue);
           layerValue = defaultValue;
         }
-        if (typeof layerValue === "undefined" && layerOperations.length === 0) {
+        if (typeof layerValue === "undefined" && !layerOperations?.length) {
           if (layer.deletedIDs.size > 0) {
+            if (!layerIDs) layerIDs = [];
             layerIDs.push(layer.id);
           }
           continue;
@@ -91,17 +109,21 @@ class InMemoryStorage {
             displayLayers: [layer.id]
           };
         }
+        if (!layerIDs) layerIDs = [];
         layerIDs.push(layer.id);
-        if (layerOperations.length > 0) {
+        if (layerOperations?.length) {
           for (const op of layerOperations) {
             if (isRemoveOperation(op)) {
-              operations.remove.add(op.id);
+              if (!removeSet) removeSet = /* @__PURE__ */ new Set();
+              removeSet.add(op.id);
             }
             if (isInsertOperation(op)) {
               if (op.location === OperationLocation.end) {
-                operations.insert[op.location].unshift(op.id);
+                if (!insertEnd) insertEnd = [];
+                insertEnd.unshift(op.id);
               } else {
-                operations.insert[op.location].push(op.id);
+                if (!insertStart) insertStart = [];
+                insertStart.push(op.id);
               }
             }
             if (isDeleteOperation(op)) {
@@ -116,15 +138,13 @@ class InMemoryStorage {
         if (typeof layerValue === "undefined") {
           continue;
         }
-        if (!operations.remove.size && !operations.insert.start.length && !operations.insert.end.length) {
+        if (!removeSet?.size && !insertStart?.length && !insertEnd?.length) {
           return { value: layerValue, displayLayers: layerIDs, kind: "link" };
         }
         return {
-          value: [
-            ...operations.insert.start,
-            ...layerValue,
-            ...operations.insert.end
-          ].filter((value) => !operations.remove.has(value)),
+          value: [...insertStart ?? [], ...layerValue, ...insertEnd ?? []].filter(
+            (value) => !removeSet?.has(value)
+          ),
           displayLayers: layerIDs,
           kind
         };
@@ -153,7 +173,7 @@ class InMemoryStorage {
       break;
     }
     if (startingIndex === null) {
-      throw new Error("could not find layer with id: " + id);
+      throw new Error(`could not find layer with id: ${id}`);
     }
     if (startingIndex === -1) {
       startingIndex = 0;
@@ -210,9 +230,20 @@ class InMemoryStorage {
     layer ??= this.createLayer(true);
     layer.fields = fields;
     layer.links = links;
+    return layer;
+  }
+  // fast typename lookup with lazy-populate fallback for records written via hydrate()
+  getTypename(id) {
+    let typename = this.typenames.get(id);
+    if (typename === void 0) {
+      typename = this.get(id, "__typename").value;
+      if (typename !== void 0) this.typenames.set(id, typename);
+    }
+    return typename;
   }
   reset() {
     this.data = [];
+    this.typenames.clear();
   }
 }
 class Layer {
@@ -232,23 +263,18 @@ class Layer {
     return [this.fields[id]?.[field], "scalar"];
   }
   getOperations(id, field) {
-    if (this.operations[id]?.deleted) {
-      return [
-        {
-          kind: OperationKind.delete,
-          target: id
-        }
-      ];
-    }
-    if (this.operations[id]?.fields?.[field]) {
-      return this.operations[id].fields[field];
-    }
+    const ops = this.operations[id];
+    if (!ops) return void 0;
+    if (ops.deleted) return [{ kind: OperationKind.delete, target: id }];
+    return ops.fields?.[field];
   }
   writeField(id, field, value) {
-    this.fields[id] = {
-      ...this.fields[id],
-      [field]: value
-    };
+    const record = this.fields[id];
+    if (record) {
+      record[field] = value;
+    } else {
+      this.fields[id] = { [field]: value };
+    }
     return this.id;
   }
   writeLink(id, field, value) {
@@ -269,14 +295,24 @@ class Layer {
         );
       }
     }
-    this.links[id] = {
-      ...this.links[id],
-      [field]: value
-    };
+    const linkRecord = this.links[id];
+    if (linkRecord) {
+      linkRecord[field] = value;
+    } else {
+      this.links[id] = { [field]: value };
+    }
     return this.id;
   }
   isDisplayLayer(displayLayers) {
-    return displayLayers.length === 0 || displayLayers.includes(this.id) || Math.max(...displayLayers) < this.id;
+    const n = displayLayers.length;
+    if (n === 0) return true;
+    let max = 0;
+    for (let i = 0; i < n; i++) {
+      const d = displayLayers[i];
+      if (d === this.id) return true;
+      if (d > max) max = d;
+    }
+    return max < this.id;
   }
   clear() {
     this.links = {};
@@ -356,6 +392,40 @@ class Layer {
           fields[fieldName] = [...fields[fieldName] || [], ...operations];
         }
       }
+      for (const [fieldName, ops2] of Object.entries(fields)) {
+        const insertCount = /* @__PURE__ */ new Map();
+        const removeCount = /* @__PURE__ */ new Map();
+        for (const op of ops2) {
+          if (isInsertOperation(op))
+            insertCount.set(op.id, (insertCount.get(op.id) ?? 0) + 1);
+          else if (isRemoveOperation(op))
+            removeCount.set(op.id, (removeCount.get(op.id) ?? 0) + 1);
+        }
+        const net = /* @__PURE__ */ new Map();
+        for (const [id2, n] of insertCount) net.set(id2, n);
+        for (const [id2, n] of removeCount) net.set(id2, (net.get(id2) ?? 0) - n);
+        const keptInserts = /* @__PURE__ */ new Map();
+        const keptRemoves = /* @__PURE__ */ new Map();
+        fields[fieldName] = ops2.filter((op) => {
+          if (isInsertOperation(op)) {
+            const n = net.get(op.id) ?? 0;
+            if (n <= 0) return false;
+            const kept = keptInserts.get(op.id) ?? 0;
+            if (kept >= n) return false;
+            keptInserts.set(op.id, kept + 1);
+            return true;
+          }
+          if (isRemoveOperation(op)) {
+            const n = net.get(op.id) ?? 0;
+            if (n >= 0) return false;
+            const kept = keptRemoves.get(op.id) ?? 0;
+            if (kept >= -n) return false;
+            keptRemoves.set(op.id, kept + 1);
+            return true;
+          }
+          return true;
+        });
+      }
       if (Object.keys(fields).length > 0) {
         this.operations[id] = {
           ...this.operations[id],
@@ -383,7 +453,9 @@ class Layer {
         this.writeLink(id, field, value);
       }
     }
-    layer.deletedIDs.forEach((v) => this.deletedIDs.add(v));
+    layer.deletedIDs.forEach((v) => {
+      this.deletedIDs.add(v);
+    });
   }
   addFieldOperation(id, field, operation) {
     this.operations = {

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

@@ -1,15 +1,16 @@
 function evaluateKey(key, variables = null) {
+  if (!key.includes("$")) return key;
   let evaluated = "";
   let varName = "";
   let inString = false;
   for (const char of key) {
     if (varName) {
-      if (varChars.includes(char)) {
+      if (varCharSet.has(char)) {
         varName += char;
         continue;
       }
       const value = variables?.[varName.slice(1)];
-      evaluated += typeof value !== "undefined" ? JSON.stringify(value) : "undefined";
+      evaluated += JSON.stringify(value ?? null);
       varName = "";
     }
     if (char === "$" && !inString) {
@@ -23,7 +24,7 @@ function evaluateKey(key, variables = null) {
   }
   return evaluated;
 }
-const varChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789";
+const varCharSet = new Set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789");
 const rootID = "_ROOT_";
 export {
   evaluateKey,