houdini 2.0.5 → 2.0.6

package/build/cmd/init.js

@@ -472,7 +472,7 @@ async function packageJSON(targetPath, frameworkInfo) {
   }
   packageJSON2.devDependencies = {
     ...packageJSON2.devDependencies,
-    houdini: "^2.0.5"
+    houdini: "^2.0.6"
   };
   if (frameworkInfo.framework === "svelte" || frameworkInfo.framework === "kit") {
     packageJSON2.devDependencies = {

package/build/lib/database.js

@@ -540,6 +540,7 @@ async function write_config(db, config, invoke_hook, plugins, mode, logger = new
   db.run("DELETE FROM watch_schema_config");
   db.run("DELETE FROM scalar_config");
   db.run("DELETE FROM type_configs");
+  db.run("DELETE FROM runtime_scalar_definitions");
   db.run(
     `INSERT INTO config (
 			include, exclude, schema_path, definitions_path, cache_buffer_size,

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "houdini",
-    "version": "2.0.5",
+    "version": "2.0.6",
     "description": "The disappearing GraphQL clients",
     "keywords": [
         "typescript",

package/build/runtime/cache/index.js

@@ -171,7 +171,12 @@ class Cache {
     return this._internal_unstable.storage.serialize();
   }
   hydrate(...args) {
-    return this._internal_unstable.storage.hydrate(...args);
+    const layer = this._internal_unstable.storage.hydrate(...args);
+    const snapshot = args[0];
+    if (snapshot) {
+      this._internal_unstable.staleManager.registerHydration(snapshot);
+    }
+    return layer;
   }
   clearLayer(layerID) {
     const layer = this._internal_unstable.storage.getLayer(layerID);

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

@@ -3,7 +3,9 @@ export declare class StaleManager {
     #private;
     cache: Cache;
     private fieldsTime;
+    private pendingHydrated;
     constructor(cache: Cache);
+    registerHydration(snapshot: HydratedSnapshot): void;
     /**
      * get the FieldTime info
      * @param id User:1
@@ -30,3 +32,8 @@ export declare class StaleManager {
     delete(id: string, field: string): void;
     reset(): void;
 }
+type HydratedSnapshot = {
+    fields?: Record<string, Record<string, unknown>>;
+    links?: Record<string, Record<string, unknown>>;
+};
+export {};

package/build/runtime/cache/staleManager.js

@@ -11,9 +11,41 @@ class StaleManager {
   // null => data stale (stale)
   // nulls mean that the value is stale, and the number is the time that the value was set
   fieldsTime = /* @__PURE__ */ new Map();
+  // snapshots that arrived via hydration and haven't been registered yet. field times
+  // are normally recorded per write, but hydration assigns whole layers at once and has
+  // to stay O(1) — so we hold onto the snapshot and only materialize its field times
+  // when a mark* actually needs them (staleness marks are rare; hydration happens on
+  // every page load). until then a hydrated field reads as "no entry", exactly how it
+  // read before any mark existed.
+  pendingHydrated = [];
   constructor(cache) {
     this.cache = cache;
   }
+  // note a hydrated snapshot whose fields should participate in staleness. O(1): the
+  // per-field registration is deferred to the first mark* call (see #flushHydrated)
+  registerHydration(snapshot) {
+    this.pendingHydrated.push(snapshot);
+  }
+  #flushHydrated() {
+    if (this.pendingHydrated.length === 0) {
+      return;
+    }
+    const now = Date.now();
+    for (const snapshot of this.pendingHydrated) {
+      for (const source of [snapshot.fields, snapshot.links]) {
+        for (const [id, fields] of Object.entries(source ?? {})) {
+          this.#initMapId(id);
+          const map = this.fieldsTime.get(id);
+          for (const field of Object.keys(fields)) {
+            if (!map.has(field)) {
+              map.set(field, now);
+            }
+          }
+        }
+      }
+    }
+    this.pendingHydrated = [];
+  }
   #initMapId = (id) => {
     if (!this.fieldsTime.get(id)) {
       this.fieldsTime.set(id, /* @__PURE__ */ new Map());
@@ -46,6 +78,7 @@ class StaleManager {
     this.fieldsTime.get(id)?.set(field, null);
   }
   markAllStale() {
+    this.#flushHydrated();
     for (const [id, fieldMap] of this.fieldsTime.entries()) {
       for (const [field] of fieldMap.entries()) {
         this.markFieldStale(id, field);
@@ -53,6 +86,7 @@ class StaleManager {
     }
   }
   markRecordStale(id) {
+    this.#flushHydrated();
     const fieldsTimeOfType = this.fieldsTime.get(id);
     if (fieldsTimeOfType) {
       for (const [field] of fieldsTimeOfType.entries()) {
@@ -61,6 +95,7 @@ class StaleManager {
     }
   }
   markTypeStale(type) {
+    this.#flushHydrated();
     for (const [id, fieldMap] of this.fieldsTime.entries()) {
       if (id.startsWith(`${type}:`)) {
         for (const [field] of fieldMap.entries()) {
@@ -70,6 +105,7 @@ class StaleManager {
     }
   }
   markTypeFieldStale(type, field, when) {
+    this.#flushHydrated();
     const key = computeKey({ field, args: when });
     for (const [id, fieldMap] of this.fieldsTime.entries()) {
       if (id.startsWith(`${type}:`)) {
@@ -96,6 +132,7 @@ class StaleManager {
   }
   reset() {
     this.fieldsTime.clear();
+    this.pendingHydrated = [];
   }
 }
 export {

package/build/runtime/lru.d.ts

@@ -17,7 +17,8 @@
 export declare class LRUCache<T> {
     _capacity: number;
     _map: Map<string, T>;
-    constructor(capacity?: number);
+    _onEvict?: (value: T, key: string) => void;
+    constructor(capacity?: number, onEvict?: (value: T, key: string) => void);
     set(key: string, value: T): void;
     get(key: string): T | null;
     has(key: string): boolean;
@@ -26,7 +27,7 @@ export declare class LRUCache<T> {
     capacity(): number;
     clear(): void;
 }
-export declare function createLRUCache<T>(capacity?: number): LRUCache<T>;
+export declare function createLRUCache<T>(capacity?: number, onEvict?: (value: T, key: string) => void): LRUCache<T>;
 /**
 MIT License
 

package/build/runtime/lru.js

@@ -1,17 +1,29 @@
 class LRUCache {
   _capacity;
   _map;
-  constructor(capacity = 1e3) {
+  // invoked whenever a value leaves the cache (capacity eviction, delete, overwrite,
+  // clear) so owners of resources with teardown (subscriptions, stores) can dispose them
+  _onEvict;
+  constructor(capacity = 1e3, onEvict) {
     this._capacity = capacity;
     this._map = /* @__PURE__ */ new Map();
+    this._onEvict = onEvict;
   }
   set(key, value) {
+    const existing = this._map.get(key);
     this._map.delete(key);
+    if (existing !== void 0 && existing !== value) {
+      this._onEvict?.(existing, key);
+    }
     this._map.set(key, value);
     if (this._map.size > this._capacity) {
       const firstKey = this._map.keys().next();
       if (!firstKey.done) {
+        const evicted = this._map.get(firstKey.value);
         this._map.delete(firstKey.value);
+        if (evicted !== void 0) {
+          this._onEvict?.(evicted, firstKey.value);
+        }
       }
     }
   }
@@ -27,7 +39,11 @@ class LRUCache {
     return this._map.has(key);
   }
   delete(key) {
+    const existing = this._map.get(key);
     this._map.delete(key);
+    if (existing !== void 0) {
+      this._onEvict?.(existing, key);
+    }
   }
   size() {
     return this._map.size;
@@ -36,11 +52,15 @@ class LRUCache {
     return this._capacity - this._map.size;
   }
   clear() {
+    const entries = [...this._map.entries()];
     this._map.clear();
+    for (const [key, value] of entries) {
+      this._onEvict?.(value, key);
+    }
   }
 }
-function createLRUCache(capacity = 1e3) {
-  return new LRUCache(capacity);
+function createLRUCache(capacity = 1e3, onEvict) {
+  return new LRUCache(capacity, onEvict);
 }
 export {
   LRUCache,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "The disappearing GraphQL clients",
   "keywords": [
     "typescript",