houdini 1.0.0-next.2 → 1.0.0-next.21

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

@@ -22,12 +22,15 @@ __export(cache_exports, {
   rootID: () => rootID
 });
 module.exports = __toCommonJS(cache_exports);
+var import_lib = require("../lib");
 var import_config = require("../lib/config");
 var import_deepEquals = require("../lib/deepEquals");
+var import_flatten = require("../lib/flatten");
 var import_selection = require("../lib/selection");
 var import_gc = require("./gc");
 var import_lists = require("./lists");
 var import_schema = require("./schema");
+var import_staleManager = require("./staleManager");
 var import_storage = require("./storage");
 var import_stuff = require("./stuff");
 var import_subscription = require("./subscription");
@@ -40,6 +43,7 @@ class Cache {
       subscriptions: new import_subscription.InMemorySubscriptions(this),
       lists: new import_lists.ListManager(this, rootID),
       lifetimes: new import_gc.GarbageCollector(this),
+      staleManager: new import_staleManager.StaleManager(this),
       schema: new import_schema.SchemaManager(this)
     });
     if (config) {
@@ -69,13 +73,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 = {}) {
@@ -111,6 +116,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 = (0, import_lib.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;
@@ -126,6 +155,7 @@ class CacheInternal {
   lists;
   cache;
   lifetimes;
+  staleManager;
   schema;
   constructor({
     storage,
@@ -133,6 +163,7 @@ class CacheInternal {
     lists,
     cache,
     lifetimes,
+    staleManager,
     schema
   }) {
     this.storage = storage;
@@ -140,6 +171,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 {
@@ -157,10 +189,11 @@ class CacheInternal {
     selection,
     variables = {},
     parent = rootID,
-    applyUpdates = false,
+    applyUpdates,
     layer,
     toNotify = [],
-    forceNotify
+    forceNotify,
+    forceStale
   }) {
     if (this._disabled) {
       return [];
@@ -178,7 +211,7 @@ class CacheInternal {
         selection: fieldSelection,
         operations,
         abstract: isAbstract,
-        update,
+        updates,
         nullable
       } = targetSelection[field];
       const key = (0, import_stuff.evaluateKey)(keyRaw, variables);
@@ -195,16 +228,31 @@ class CacheInternal {
       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 = !(0, import_deepEquals.deepEquals)(newValue, previousValue);
         if (displayLayer && (valueChanged || forceNotify)) {
           toNotify.push(...currentSubscribers);
@@ -214,7 +262,7 @@ class CacheInternal {
         if (previousValue === null) {
           continue;
         }
-        const previousLinks = (0, import_stuff.flattenList)([previousValue]);
+        const previousLinks = (0, import_flatten.flatten)([previousValue]);
         for (const link of previousLinks) {
           this.subscriptions.remove(link, fieldSelection, specs, variables);
         }
@@ -264,7 +312,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 "";
           }
@@ -292,7 +340,7 @@ class CacheInternal {
           layer,
           forceNotify
         });
-        if (applyUpdates && update) {
+        if (applyUpdates && updates) {
           if (key === "edges") {
             const newNodeIDs = [];
             for (const id of newIDs) {
@@ -320,12 +368,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;
@@ -411,12 +464,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 = (0, import_selection.getFieldsForType)(selection, typename);
     for (const [
@@ -425,6 +479,10 @@ class CacheInternal {
     ] of Object.entries(targetSelection)) {
       const key = (0, import_stuff.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) {
@@ -464,6 +522,9 @@ class CacheInternal {
         if (listValue.partial) {
           partial = true;
         }
+        if (listValue.stale) {
+          stale = true;
+        }
         if (listValue.hasData || value.length === 0) {
           hasData = true;
         }
@@ -478,6 +539,9 @@ class CacheInternal {
         if (objectFields.partial) {
           partial = true;
         }
+        if (objectFields.stale) {
+          stale = true;
+        }
         if (objectFields.hasData) {
           hasData = true;
         }
@@ -489,6 +553,7 @@ class CacheInternal {
     return {
       data: cascadeNull ? null : target,
       partial: hasData && partial,
+      stale: hasData && stale,
       hasData
     };
   }
@@ -516,6 +581,7 @@ class CacheInternal {
   }) {
     const result = [];
     let partialData = false;
+    let stale = false;
     let hasValues = false;
     for (const entry of linkedList) {
       if (Array.isArray(entry)) {
@@ -535,7 +601,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,
@@ -545,6 +616,9 @@ class CacheInternal {
       if (partial) {
         partialData = true;
       }
+      if (local_stale) {
+        stale = true;
+      }
       if (hasData) {
         hasValues = true;
       }
@@ -552,6 +626,7 @@ class CacheInternal {
     return {
       data: result,
       partial: partialData,
+      stale,
       hasData: hasValues
     };
   }

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

@@ -37,6 +37,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) {
@@ -50,6 +52,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-cjs/cache/lists.d.ts

@@ -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-cjs/cache/lists.js

@@ -23,8 +23,8 @@ __export(lists_exports, {
   ListManager: () => ListManager
 });
 module.exports = __toCommonJS(lists_exports);
+var import_flatten = require("../lib/flatten");
 var import_cache = require("./cache");
-var import_stuff = require("./stuff");
 class ListManager {
   rootID;
   cache;
@@ -176,7 +176,7 @@ class List {
                 edges: {
                   keyRaw: "edges",
                   type: "ConnectionEdge",
-                  update: where === "first" ? "prepend" : "append",
+                  updates: ["append", "prepend"],
                   selection: {
                     fields: {
                       node: {
@@ -212,7 +212,7 @@ class List {
           newEntries: {
             keyRaw: this.key,
             type: listType,
-            update: where === "first" ? "prepend" : "append",
+            updates: ["append", "prepend"],
             selection: {
               ...selection,
               fields: {
@@ -235,7 +235,7 @@ class List {
       data: insertData,
       variables,
       parent: this.recordID,
-      applyUpdates: true
+      applyUpdates: [where === "first" ? "prepend" : "append"]
     });
   }
   removeID(id, variables = {}) {
@@ -258,7 +258,7 @@ class List {
         embeddedConnectionID,
         "edges"
       );
-      for (const edge of (0, import_stuff.flattenList)(edges) || []) {
+      for (const edge of (0, import_flatten.flatten)(edges) || []) {
         if (!edge) {
           continue;
         }
@@ -336,7 +336,7 @@ class List {
     let entries = [];
     let value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
     if (!this.connection) {
-      entries = (0, import_stuff.flattenList)(value);
+      entries = (0, import_flatten.flatten)(value);
     } else {
       entries = this.cache._internal_unstable.storage.get(value, "edges").value;
     }
@@ -350,6 +350,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-cjs/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;
+}

package/build/runtime-cjs/cache/staleManager.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var staleManager_exports = {};
+__export(staleManager_exports, {
+  StaleManager: () => StaleManager
+});
+module.exports = __toCommonJS(staleManager_exports);
+var import_lib = require("../lib");
+class StaleManager {
+  cache;
+  fieldsTime = /* @__PURE__ */ new Map();
+  constructor(cache) {
+    this.cache = cache;
+  }
+  #initMapId = (id) => {
+    if (!this.fieldsTime.get(id)) {
+      this.fieldsTime.set(id, /* @__PURE__ */ new Map());
+    }
+  };
+  getFieldTime(id, field) {
+    return this.fieldsTime.get(id)?.get(field);
+  }
+  setFieldTimeToNow(id, field) {
+    this.#initMapId(id);
+    this.fieldsTime.get(id)?.set(field, new Date().valueOf());
+  }
+  markFieldStale(id, field) {
+    this.#initMapId(id);
+    this.fieldsTime.get(id)?.set(field, null);
+  }
+  markAllStale() {
+    for (const [id, fieldMap] of this.fieldsTime.entries()) {
+      for (const [field] of fieldMap.entries()) {
+        this.markFieldStale(id, field);
+      }
+    }
+  }
+  markRecordStale(id) {
+    const fieldsTimeOfType = this.fieldsTime.get(id);
+    if (fieldsTimeOfType) {
+      for (const [field] of fieldsTimeOfType.entries()) {
+        this.markFieldStale(id, field);
+      }
+    }
+  }
+  markTypeStale(type) {
+    for (const [id, fieldMap] of this.fieldsTime.entries()) {
+      if (id.startsWith(`${type}:`)) {
+        for (const [field] of fieldMap.entries()) {
+          this.markFieldStale(id, field);
+        }
+      }
+    }
+  }
+  markTypeFieldStale(type, field, when) {
+    const key = (0, import_lib.computeKey)({ field, args: when });
+    for (const [id, fieldMap] of this.fieldsTime.entries()) {
+      if (id.startsWith(`${type}:`)) {
+        for (const local_field of fieldMap.keys()) {
+          if (local_field === key) {
+            this.markFieldStale(id, field);
+          }
+        }
+      }
+    }
+  }
+  delete(id, field) {
+    if (this.fieldsTime.has(id)) {
+      this.fieldsTime.get(id)?.delete(field);
+      if (this.fieldsTime.get(id)?.size === 0) {
+        this.fieldsTime.delete(id);
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StaleManager
+});

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

@@ -7,7 +7,7 @@ export declare class InMemoryStorage {
     get layerCount(): number;
     get nextRank(): number;
     createLayer(optimistic?: boolean): Layer;
-    insert(id: string, field: string, location: OperationLocation, target: string): void;
+    insert(id: string, field: string, location: OperationLocations, target: string): void;
     remove(id: string, field: string, target: string): void;
     delete(id: string): void;
     deleteField(id: string, field: string): void;
@@ -21,7 +21,7 @@ export declare class InMemoryStorage {
         kind: 'link' | 'scalar' | 'unknown';
         displayLayers: number[];
     };
-    writeLink(id: string, field: string, value: string | LinkedList): number;
+    writeLink(id: string, field: string, value: string | NestedList): number;
     writeField(id: string, field: string, value: GraphQLValue): number;
     resolveLayer(id: number): void;
     get topLayer(): Layer;
@@ -37,7 +37,7 @@ export declare class Layer {
     get(id: string, field: string): [GraphQLField, 'link' | 'scalar'];
     getOperations(id: string, field: string): Operation[] | undefined;
     writeField(id: string, field: string, value: GraphQLField): LayerID;
-    writeLink(id: string, field: string, value: null | string | LinkedList): LayerID;
+    writeLink(id: string, field: string, value: null | string | NestedList): LayerID;
     isDisplayLayer(displayLayers: number[]): boolean;
     clear(): void;
     replaceID({ from, to }: {
@@ -47,19 +47,19 @@ export declare class Layer {
     removeUndefinedFields(): void;
     delete(id: string): void;
     deleteField(id: string, field: string): void;
-    insert(id: string, field: string, where: OperationLocation, target: string): void;
+    insert(id: string, field: string, where: OperationLocations, target: string): void;
     remove(id: string, field: string, target: string): void;
     writeLayer(layer: Layer): void;
     private addFieldOperation;
 }
-type GraphQLField = GraphQLValue | LinkedList;
+type GraphQLField = GraphQLValue | NestedList;
 type EntityMap<_Value> = {
     [id: string]: {
         [field: string]: _Value;
     };
 };
 type EntityFieldMap = EntityMap<GraphQLField>;
-type LinkMap = EntityMap<string | null | LinkedList>;
+type LinkMap = EntityMap<string | null | NestedList>;
 type OperationMap = {
     [id: string]: {
         deleted?: boolean;
@@ -69,30 +69,33 @@ type OperationMap = {
         };
     };
 };
-type LinkedList<_Result = string> = (_Result | null | LinkedList<_Result>)[];
+type NestedList<_Result = string> = (_Result | null | NestedList<_Result>)[];
 type InsertOperation = {
-    kind: OperationKind.insert;
-    location: OperationLocation;
+    kind: 'insert';
+    location: OperationLocations;
     id: string;
 };
 type RemoveOperation = {
-    kind: OperationKind.remove;
+    kind: 'remove';
     id: string;
 };
 type DeleteOperation = {
-    kind: OperationKind.delete;
+    kind: 'delete';
     target: string;
 };
 type ListOperation = InsertOperation | RemoveOperation;
 type Operation = ListOperation | DeleteOperation;
-export declare enum OperationLocation {
-    start = "start",
-    end = "end"
-}
-export declare enum OperationKind {
-    delete = "delete",
-    insert = "insert",
-    remove = "remove"
-}
+type ValuesOf<Target> = Target[keyof Target];
+export declare const OperationLocation: {
+    readonly start: "start";
+    readonly end: "end";
+};
+export type OperationLocations = ValuesOf<typeof OperationLocation>;
+export declare const OperationKind: {
+    readonly delete: "delete";
+    readonly insert: "insert";
+    readonly remove: "remove";
+};
+export type OperationKinds = ValuesOf<typeof OperationKind>;
 export type LayerID = number;
 export {};

package/build/runtime-cjs/cache/storage.js

@@ -24,7 +24,7 @@ __export(storage_exports, {
   OperationLocation: () => OperationLocation
 });
 module.exports = __toCommonJS(storage_exports);
-var import_stuff = require("./stuff");
+var import_flatten = require("../lib/flatten");
 class InMemoryStorage {
   data;
   idCount = 0;
@@ -224,7 +224,7 @@ class Layer {
   }
   writeLink(id, field, value) {
     const valueList = Array.isArray(value) ? value : [value];
-    for (const value2 of (0, import_stuff.flattenList)(valueList)) {
+    for (const value2 of (0, import_flatten.flatten)(valueList)) {
       if (!value2) {
         continue;
       }
@@ -376,17 +376,15 @@ function isInsertOperation(value) {
 function isRemoveOperation(value) {
   return !!value && value.kind === OperationKind.remove;
 }
-var OperationLocation = /* @__PURE__ */ ((OperationLocation2) => {
-  OperationLocation2["start"] = "start";
-  OperationLocation2["end"] = "end";
-  return OperationLocation2;
-})(OperationLocation || {});
-var OperationKind = /* @__PURE__ */ ((OperationKind2) => {
-  OperationKind2["delete"] = "delete";
-  OperationKind2["insert"] = "insert";
-  OperationKind2["remove"] = "remove";
-  return OperationKind2;
-})(OperationKind || {});
+const OperationLocation = {
+  start: "start",
+  end: "end"
+};
+const OperationKind = {
+  delete: "delete",
+  insert: "insert",
+  remove: "remove"
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InMemoryStorage,

package/build/runtime-cjs/cache/stuff.d.ts

@@ -1,6 +1,4 @@
 import type { GraphQLValue } from '../lib/types';
-import type { LinkedList } from './cache';
-export declare function flattenList<T>(source: LinkedList<T>): T[];
 export declare function evaluateKey(key: string, variables?: {
     [key: string]: GraphQLValue;
 }): string;