houdini 1.0.0-next.1 → 1.0.0-next.11

package/build/runtime-esm/cache/cache.d.ts

@@ -1,10 +1,13 @@
-import { ConfigFile } from '../lib/config';
-import { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
+import type { ConfigFile } from '../lib/config';
+import type { GraphQLObject, GraphQLValue, NestedList, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
 import { GarbageCollector } from './gc';
-import { ListCollection, ListManager } from './lists';
+import type { ListCollection } from './lists';
+import { ListManager } from './lists';
 import { SchemaManager } from './schema';
-import { InMemoryStorage, Layer, LayerID } from './storage';
-import { InMemorySubscriptions } from './subscription';
+import { StaleManager } from './staleManager';
+import type { Layer, LayerID } from './storage';
+import { InMemoryStorage } from './storage';
+import { InMemorySubscriptions, type FieldSelection } from './subscription';
 export declare class Cache {
     _internal_unstable: CacheInternal;
     constructor(config?: ConfigFile);
@@ -16,19 +19,31 @@ export declare class Cache {
         variables?: {};
         parent?: string;
         layer?: LayerID | null;
-        applyUpdates?: boolean;
+        applyUpdates?: string[];
         notifySubscribers?: SubscriptionSpec[];
         forceNotify?: boolean;
+        forceStale?: boolean;
     }): SubscriptionSpec[];
     read(...args: Parameters<CacheInternal['getSelection']>): {
         data: GraphQLObject | null;
         partial: boolean;
+        stale: boolean;
     };
     subscribe(spec: SubscriptionSpec, variables?: {}): void;
     unsubscribe(spec: SubscriptionSpec, variables?: {}): void;
     list(name: string, parentID?: string, allLists?: boolean): ListCollection;
     delete(id: string): void;
     setConfig(config: ConfigFile): void;
+    markTypeStale(options?: {
+        type: string;
+        field?: string;
+        when?: {};
+    }): void;
+    markRecordStale(id: string, options: {
+        field?: string;
+        when?: {};
+    }): void;
+    getFieldTime(id: string, field: string): number | null | undefined;
 }
 declare class CacheInternal {
     private _disabled;
@@ -38,17 +53,19 @@ declare class CacheInternal {
     lists: ListManager;
     cache: Cache;
     lifetimes: GarbageCollector;
+    staleManager: StaleManager;
     schema: SchemaManager;
-    constructor({ storage, subscriptions, lists, cache, lifetimes, schema, }: {
+    constructor({ storage, subscriptions, lists, cache, lifetimes, staleManager, schema, }: {
         storage: InMemoryStorage;
         subscriptions: InMemorySubscriptions;
         lists: ListManager;
         cache: Cache;
         lifetimes: GarbageCollector;
+        staleManager: StaleManager;
         schema: SchemaManager;
     });
     setConfig(config: ConfigFile): void;
-    writeSelection({ data, selection, variables, parent, applyUpdates, layer, toNotify, forceNotify, }: {
+    writeSelection({ data, selection, variables, parent, applyUpdates, layer, toNotify, forceNotify, forceStale, }: {
         data: {
             [key: string]: GraphQLValue;
         };
@@ -59,10 +76,11 @@ declare class CacheInternal {
         parent?: string;
         root?: string;
         layer: Layer;
-        toNotify?: SubscriptionSpec[];
-        applyUpdates?: boolean;
+        toNotify?: FieldSelection[];
+        applyUpdates?: string[];
         forceNotify?: boolean;
-    }): SubscriptionSpec[];
+        forceStale?: boolean;
+    }): FieldSelection[];
     getSelection({ selection, parent, variables, stepsFromConnection, }: {
         selection: SubscriptionSelection;
         parent?: string;
@@ -71,6 +89,7 @@ declare class CacheInternal {
     }): {
         data: GraphQLObject | null;
         partial: boolean;
+        stale: boolean;
         hasData: boolean;
     };
     id(type: string, data: {} | null): string | null;
@@ -80,11 +99,12 @@ declare class CacheInternal {
     hydrateNestedList({ fields, variables, linkedList, stepsFromConnection, }: {
         fields: SubscriptionSelection;
         variables?: {};
-        linkedList: LinkedList;
+        linkedList: NestedList;
         stepsFromConnection: number | null;
     }): {
-        data: LinkedList<GraphQLValue>;
+        data: NestedList<GraphQLValue>;
         partial: boolean;
+        stale: boolean;
         hasData: boolean;
     };
     extractNestedListIDs({ value, abstract, recordID, key, linkedType, fields, variables, applyUpdates, specs, layer, forceNotify, }: {
@@ -94,17 +114,16 @@ declare class CacheInternal {
         linkedType: string;
         abstract: boolean;
         variables: {};
-        specs: SubscriptionSpec[];
-        applyUpdates: boolean;
+        specs: FieldSelection[];
+        applyUpdates?: string[];
         fields: SubscriptionSelection;
         layer: Layer;
         forceNotify?: boolean;
     }): {
-        nestedIDs: LinkedList;
+        nestedIDs: NestedList;
         newIDs: (string | null)[];
     };
     collectGarbage(): void;
 }
 export declare const rootID = "_ROOT_";
-export type LinkedList<_Result = string> = (_Result | null | LinkedList<_Result>)[];
 export {};

package/build/runtime-esm/cache/cache.js

@@ -1,11 +1,14 @@
-import { defaultConfigValues, computeID, keyFieldsForType } from "../lib/config";
+import { computeKey } from "../lib";
+import { computeID, defaultConfigValues, keyFieldsForType } from "../lib/config";
 import { deepEquals } from "../lib/deepEquals";
+import { flatten } from "../lib/flatten";
 import { getFieldsForType } from "../lib/selection";
 import { GarbageCollector } from "./gc";
 import { ListManager } from "./lists";
 import { SchemaManager } from "./schema";
+import { StaleManager } from "./staleManager";
 import { InMemoryStorage } from "./storage";
-import { evaluateKey, flattenList } from "./stuff";
+import { evaluateKey } from "./stuff";
 import { InMemorySubscriptions } from "./subscription";
 class Cache {
   _internal_unstable;
@@ -16,6 +19,7 @@ class Cache {
       subscriptions: new InMemorySubscriptions(this),
       lists: new ListManager(this, rootID),
       lifetimes: new GarbageCollector(this),
+      staleManager: new StaleManager(this),
       schema: new SchemaManager(this)
     });
     if (config) {
@@ -28,7 +32,7 @@ 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 });
+    const subscribers = this._internal_unstable.writeSelection({ ...args, layer }).map((sub) => sub[0]);
     const notified = [];
     for (const spec of subscribers.concat(notifySubscribers)) {
       if (!notified.includes(spec.set)) {
@@ -45,13 +49,14 @@ class Cache {
     return subscribers;
   }
   read(...args) {
-    const { data, partial, hasData } = this._internal_unstable.getSelection(...args);
+    const { data, partial, stale, hasData } = this._internal_unstable.getSelection(...args);
     if (!hasData) {
-      return { data: null, partial: false };
+      return { data: null, partial: false, stale: false };
     }
     return {
       data,
-      partial
+      partial,
+      stale
     };
   }
   subscribe(spec, variables = {}) {
@@ -87,6 +92,30 @@ class Cache {
   setConfig(config) {
     this._internal_unstable.setConfig(config);
   }
+  markTypeStale(options) {
+    if (!options) {
+      this._internal_unstable.staleManager.markAllStale();
+    } else if (!options.field) {
+      this._internal_unstable.staleManager.markTypeStale(options.type);
+    } else {
+      this._internal_unstable.staleManager.markTypeFieldStale(
+        options.type,
+        options.field,
+        options.when
+      );
+    }
+  }
+  markRecordStale(id, options) {
+    if (options.field) {
+      const key = computeKey({ field: options.field, args: options.when ?? {} });
+      this._internal_unstable.staleManager.markFieldStale(id, key);
+    } else {
+      this._internal_unstable.staleManager.markRecordStale(id);
+    }
+  }
+  getFieldTime(id, field) {
+    return this._internal_unstable.staleManager.getFieldTime(id, field);
+  }
 }
 class CacheInternal {
   _disabled = false;
@@ -102,6 +131,7 @@ class CacheInternal {
   lists;
   cache;
   lifetimes;
+  staleManager;
   schema;
   constructor({
     storage,
@@ -109,6 +139,7 @@ class CacheInternal {
     lists,
     cache,
     lifetimes,
+    staleManager,
     schema
   }) {
     this.storage = storage;
@@ -116,6 +147,7 @@ class CacheInternal {
     this.lists = lists;
     this.cache = cache;
     this.lifetimes = lifetimes;
+    this.staleManager = staleManager;
     this.schema = schema;
     this._disabled = typeof globalThis.window === "undefined";
     try {
@@ -133,10 +165,11 @@ class CacheInternal {
     selection,
     variables = {},
     parent = rootID,
-    applyUpdates = false,
+    applyUpdates,
     layer,
     toNotify = [],
-    forceNotify
+    forceNotify,
+    forceStale
   }) {
     if (this._disabled) {
       return [];
@@ -154,7 +187,7 @@ class CacheInternal {
         selection: fieldSelection,
         operations,
         abstract: isAbstract,
-        update,
+        updates,
         nullable
       } = targetSelection[field];
       const key = evaluateKey(keyRaw, variables);
@@ -166,20 +199,36 @@ class CacheInternal {
         link: !!fieldSelection
       });
       const currentSubscribers = this.subscriptions.get(parent, key);
+      const specs = currentSubscribers.map((sub) => sub[0]);
       const { value: previousValue, displayLayers } = this.storage.get(parent, key);
       const displayLayer = layer.isDisplayLayer(displayLayers);
       if (displayLayer) {
         this.lifetimes.resetLifetime(parent, key);
+        if (forceStale) {
+          this.staleManager.markFieldStale(parent, key);
+        } else {
+          this.staleManager.setFieldTimeToNow(parent, key);
+        }
       }
       if (!fieldSelection) {
         let newValue = value;
-        if (Array.isArray(value) && applyUpdates && update) {
-          if (update === "append") {
-            newValue = (previousValue || []).concat(value);
-          } else if (update === "prepend") {
-            newValue = value.concat(previousValue || []);
+        if (updates && applyUpdates && Array.isArray(value)) {
+          for (const update of applyUpdates) {
+            if (!updates.includes(update)) {
+              continue;
+            }
+            if (update === "append") {
+              newValue = (previousValue || []).concat(value);
+            } else if (update === "prepend") {
+              newValue = value.concat(previousValue || []);
+            }
           }
         }
+        if (updates && applyUpdates?.includes("prepend") && ["endCursor", "hasNextPage"].includes(key)) {
+          newValue = previousValue;
+        } else if (updates && applyUpdates?.includes("append") && ["startCursor", "hasPreviousPage"].includes(key)) {
+          newValue = previousValue;
+        }
         const valueChanged = !deepEquals(newValue, previousValue);
         if (displayLayer && (valueChanged || forceNotify)) {
           toNotify.push(...currentSubscribers);
@@ -189,9 +238,9 @@ class CacheInternal {
         if (previousValue === null) {
           continue;
         }
-        const previousLinks = flattenList([previousValue]);
+        const previousLinks = flatten([previousValue]);
         for (const link of previousLinks) {
-          this.subscriptions.remove(link, fieldSelection, currentSubscribers, variables);
+          this.subscriptions.remove(link, fieldSelection, specs, variables);
         }
         layer.writeLink(parent, key, null);
         toNotify.push(...currentSubscribers);
@@ -215,16 +264,10 @@ class CacheInternal {
         layer.writeLink(parent, key, linkedID);
         if (linkedID && displayLayer && (linkChange || forceNotify)) {
           if (previousValue && typeof previousValue === "string") {
-            this.subscriptions.remove(
-              previousValue,
-              fieldSelection,
-              currentSubscribers,
-              variables
-            );
+            this.subscriptions.remove(previousValue, fieldSelection, specs, variables);
           }
           this.subscriptions.addMany({
             parent: linkedID,
-            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -245,7 +288,7 @@ class CacheInternal {
         }
       } else if (Array.isArray(value) && (typeof previousValue === "undefined" || Array.isArray(previousValue))) {
         let oldIDs = [...previousValue || []];
-        const emptyEdges = !update ? [] : oldIDs.map((id) => {
+        const emptyEdges = !updates ? [] : oldIDs.map((id) => {
           if (!id) {
             return "";
           }
@@ -273,7 +316,7 @@ class CacheInternal {
           layer,
           forceNotify
         });
-        if (applyUpdates && update) {
+        if (applyUpdates && updates) {
           if (key === "edges") {
             const newNodeIDs = [];
             for (const id of newIDs) {
@@ -301,12 +344,17 @@ class CacheInternal {
               return true;
             });
           }
-          if (update === "prepend") {
-            linkedIDs = newIDs.concat(oldIDs);
-          } else if (update === "append") {
-            linkedIDs = oldIDs.concat(newIDs);
-          } else if (update === "replace") {
-            linkedIDs = newIDs;
+          for (const update of applyUpdates) {
+            if (update !== "replace" && !updates.includes(update)) {
+              continue;
+            }
+            if (update === "prepend") {
+              linkedIDs = newIDs.concat(oldIDs);
+            } else if (update === "append") {
+              linkedIDs = oldIDs.concat(newIDs);
+            } else if (update === "replace") {
+              linkedIDs = newIDs;
+            }
           }
         } else {
           linkedIDs = nestedIDs;
@@ -319,7 +367,7 @@ class CacheInternal {
           if (linkedIDs.includes(lostID) || !lostID) {
             continue;
           }
-          this.subscriptions.remove(lostID, fieldSelection, currentSubscribers, variables);
+          this.subscriptions.remove(lostID, fieldSelection, specs, variables);
         }
         if (contentChanged || oldIDs.length === 0 && newIDs.length === 0) {
           layer.writeLink(parent, key, linkedIDs);
@@ -330,7 +378,6 @@ class CacheInternal {
           }
           this.subscriptions.addMany({
             parent: id,
-            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -393,12 +440,13 @@ class CacheInternal {
     stepsFromConnection = null
   }) {
     if (parent === null) {
-      return { data: null, partial: false, hasData: true };
+      return { data: null, partial: false, stale: false, hasData: true };
     }
     const target = {};
     let hasData = false;
     let partial = false;
     let cascadeNull = false;
+    let stale = false;
     const typename = this.storage.get(parent, "__typename").value;
     let targetSelection = getFieldsForType(selection, typename);
     for (const [
@@ -407,6 +455,10 @@ class CacheInternal {
     ] of Object.entries(targetSelection)) {
       const key = evaluateKey(keyRaw, variables);
       const { value } = this.storage.get(parent, key);
+      const dt_field = this.staleManager.getFieldTime(parent, key);
+      if (dt_field === null) {
+        stale = true;
+      }
       let nextStep = stepsFromConnection;
       if (nextStep !== null) {
         if (nextStep >= 2) {
@@ -446,6 +498,9 @@ class CacheInternal {
         if (listValue.partial) {
           partial = true;
         }
+        if (listValue.stale) {
+          stale = true;
+        }
         if (listValue.hasData || value.length === 0) {
           hasData = true;
         }
@@ -460,6 +515,9 @@ class CacheInternal {
         if (objectFields.partial) {
           partial = true;
         }
+        if (objectFields.stale) {
+          stale = true;
+        }
         if (objectFields.hasData) {
           hasData = true;
         }
@@ -471,6 +529,7 @@ class CacheInternal {
     return {
       data: cascadeNull ? null : target,
       partial: hasData && partial,
+      stale: hasData && stale,
       hasData
     };
   }
@@ -498,6 +557,7 @@ class CacheInternal {
   }) {
     const result = [];
     let partialData = false;
+    let stale = false;
     let hasValues = false;
     for (const entry of linkedList) {
       if (Array.isArray(entry)) {
@@ -517,7 +577,12 @@ class CacheInternal {
         result.push(entry);
         continue;
       }
-      const { data, partial, hasData } = this.getSelection({
+      const {
+        data,
+        partial,
+        stale: local_stale,
+        hasData
+      } = this.getSelection({
         parent: entry,
         selection: fields,
         variables,
@@ -527,6 +592,9 @@ class CacheInternal {
       if (partial) {
         partialData = true;
       }
+      if (local_stale) {
+        stale = true;
+      }
       if (hasData) {
         hasValues = true;
       }
@@ -534,6 +602,7 @@ class CacheInternal {
     return {
       data: result,
       partial: partialData,
+      stale,
       hasData: hasValues
     };
   }

package/build/runtime-esm/cache/gc.d.ts

@@ -1,4 +1,4 @@
-import { Cache } from './cache';
+import type { Cache } from './cache';
 export declare class GarbageCollector {
     cache: Cache;
     private lifetimes;

package/build/runtime-esm/cache/gc.js

@@ -14,6 +14,8 @@ class GarbageCollector {
     this.lifetimes.get(id).set(field, 0);
   }
   tick() {
+    const dt_tick = Date.now().valueOf();
+    const config_max_time = this.cache._internal_unstable.config.defaultLifetime;
     for (const [id, fieldMap] of this.lifetimes.entries()) {
       for (const [field, lifetime] of fieldMap.entries()) {
         if (this.cache._internal_unstable.subscriptions.get(id, field).length > 0) {
@@ -27,6 +29,13 @@ class GarbageCollector {
           if ([...fieldMap.keys()].length === 0) {
             this.lifetimes.delete(id);
           }
+          this.cache._internal_unstable.staleManager.delete(id, field);
+        }
+        if (config_max_time && config_max_time > 0) {
+          const dt_valueOf = this.cache.getFieldTime(id, field);
+          if (dt_valueOf && dt_tick - dt_valueOf > config_max_time) {
+            this.cache._internal_unstable.staleManager.markFieldStale(id, field);
+          }
         }
       }
     }

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

@@ -1,5 +1,5 @@
-import { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../lib/types';
-import { Cache } from './cache';
+import type { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../lib/types';
+import type { Cache } from './cache';
 export declare class ListManager {
     rootID: string;
     cache: Cache;
@@ -55,6 +55,7 @@ export declare class List {
 export declare class ListCollection {
     lists: List[];
     constructor(lists: List[]);
+    get selection(): SubscriptionSelection;
     append(...args: Parameters<List['append']>): void;
     prepend(...args: Parameters<List['prepend']>): void;
     addToList(...args: Parameters<List['addToList']>): void;

package/build/runtime-esm/cache/lists.js

@@ -1,5 +1,5 @@
+import { flatten } from "../lib/flatten";
 import { rootID } from "./cache";
-import { flattenList } from "./stuff";
 class ListManager {
   rootID;
   cache;
@@ -151,7 +151,7 @@ class List {
                 edges: {
                   keyRaw: "edges",
                   type: "ConnectionEdge",
-                  update: where === "first" ? "prepend" : "append",
+                  updates: ["append", "prepend"],
                   selection: {
                     fields: {
                       node: {
@@ -187,7 +187,7 @@ class List {
           newEntries: {
             keyRaw: this.key,
             type: listType,
-            update: where === "first" ? "prepend" : "append",
+            updates: ["append", "prepend"],
             selection: {
               ...selection,
               fields: {
@@ -210,7 +210,7 @@ class List {
       data: insertData,
       variables,
       parent: this.recordID,
-      applyUpdates: true
+      applyUpdates: [where === "first" ? "prepend" : "append"]
     });
   }
   removeID(id, variables = {}) {
@@ -233,7 +233,7 @@ class List {
         embeddedConnectionID,
         "edges"
       );
-      for (const edge of flattenList(edges) || []) {
+      for (const edge of flatten(edges) || []) {
         if (!edge) {
           continue;
         }
@@ -257,11 +257,11 @@ class List {
     this.cache._internal_unstable.subscriptions.remove(
       targetID,
       this.connection ? this.selection.fields.edges.selection : this.selection,
-      subscribers,
+      subscribers.map((sub) => sub[0]),
       variables
     );
     this.cache._internal_unstable.storage.remove(parentID, targetKey, targetID);
-    for (const spec of subscribers) {
+    for (const [spec] of subscribers) {
       spec.set(
         this.cache._internal_unstable.getSelection({
           parent: spec.parentID || this.manager.rootID,
@@ -311,7 +311,7 @@ class List {
     let entries = [];
     let value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
     if (!this.connection) {
-      entries = flattenList(value);
+      entries = flatten(value);
     } else {
       entries = this.cache._internal_unstable.storage.get(value, "edges").value;
     }
@@ -325,6 +325,9 @@ class ListCollection {
   constructor(lists) {
     this.lists = lists;
   }
+  get selection() {
+    return this.lists[0].selection;
+  }
   append(...args) {
     this.lists.forEach((list) => list.append(...args));
   }

package/build/runtime-esm/cache/schema.d.ts

@@ -1,5 +1,5 @@
-import { ConfigFile } from '../lib';
-import { Cache } from './cache';
+import type { ConfigFile } from '../lib/config';
+import type { Cache } from './cache';
 export type TypeInfo = {
     type: string;
     nullable: boolean;

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

@@ -0,0 +1,30 @@
+import type { Cache } from './cache';
+export declare class StaleManager {
+    #private;
+    cache: Cache;
+    private fieldsTime;
+    constructor(cache: Cache);
+    /**
+     * get the FieldTime info
+     * @param id User:1
+     * @param field firstName
+     */
+    getFieldTime(id: string, field: string): number | undefined | null;
+    /**
+     * set the date to a field
+     * @param id User:1
+     * @param field firstName
+     */
+    setFieldTimeToNow(id: string, field: string): void;
+    /**
+     * set null to a field (stale)
+     * @param id User:1
+     * @param field firstName
+     */
+    markFieldStale(id: string, field: string): void;
+    markAllStale(): void;
+    markRecordStale(id: string): void;
+    markTypeStale(type: string): void;
+    markTypeFieldStale(type: string, field: string, when?: {}): void;
+    delete(id: string, field: string): void;
+}