houdini 1.0.0-next.4 → 1.0.0-next.5

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

@@ -1,9 +1,11 @@
-import { defaultConfigValues, computeID, keyFieldsForType } from "../lib/config";
+import { computeKey } from "../lib";
+import { computeID, defaultConfigValues, keyFieldsForType } from "../lib/config";
 import { deepEquals } from "../lib/deepEquals";
 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 { InMemorySubscriptions } from "./subscription";
@@ -16,6 +18,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) {
@@ -45,13 +48,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 +91,30 @@ class Cache {
   setConfig(config) {
     this._internal_unstable.setConfig(config);
   }
+  markTypeStale(type, options = {}) {
+    if (!type) {
+      this._internal_unstable.staleManager.markAllStale();
+    } else if (!options.field) {
+      this._internal_unstable.staleManager.markTypeStale(type);
+    } else {
+      this._internal_unstable.staleManager.markTypeFieldStale(
+        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 +130,7 @@ class CacheInternal {
   lists;
   cache;
   lifetimes;
+  staleManager;
   schema;
   constructor({
     storage,
@@ -109,6 +138,7 @@ class CacheInternal {
     lists,
     cache,
     lifetimes,
+    staleManager,
     schema
   }) {
     this.storage = storage;
@@ -116,6 +146,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 {
@@ -136,7 +167,8 @@ class CacheInternal {
     applyUpdates,
     layer,
     toNotify = [],
-    forceNotify
+    forceNotify,
+    forceStale
   }) {
     if (this._disabled) {
       return [];
@@ -171,6 +203,11 @@ 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;
@@ -402,12 +439,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 [
@@ -416,6 +454,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) {
@@ -455,6 +497,9 @@ class CacheInternal {
         if (listValue.partial) {
           partial = true;
         }
+        if (listValue.stale) {
+          stale = true;
+        }
         if (listValue.hasData || value.length === 0) {
           hasData = true;
         }
@@ -469,6 +514,9 @@ class CacheInternal {
         if (objectFields.partial) {
           partial = true;
         }
+        if (objectFields.stale) {
+          stale = true;
+        }
         if (objectFields.hasData) {
           hasData = true;
         }
@@ -480,6 +528,7 @@ class CacheInternal {
     return {
       data: cascadeNull ? null : target,
       partial: hasData && partial,
+      stale: hasData && stale,
       hasData
     };
   }
@@ -507,6 +556,7 @@ class CacheInternal {
   }) {
     const result = [];
     let partialData = false;
+    let stale = false;
     let hasValues = false;
     for (const entry of linkedList) {
       if (Array.isArray(entry)) {
@@ -526,7 +576,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,
@@ -536,6 +591,9 @@ class CacheInternal {
       if (partial) {
         partialData = true;
       }
+      if (local_stale) {
+        stale = true;
+      }
       if (hasData) {
         hasValues = true;
       }
@@ -543,6 +601,7 @@ class CacheInternal {
     return {
       data: result,
       partial: partialData,
+      stale,
       hasData: hasValues
     };
   }

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/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-esm/cache/staleManager.js

@@ -0,0 +1,71 @@
+import { computeKey } from "../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 = 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);
+      }
+    }
+  }
+}
+export {
+  StaleManager
+};

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

@@ -19,10 +19,11 @@ export declare class InMemorySubscriptions {
             [key: string]: GraphQLValue;
         };
     }): void;
-    addFieldSubscription({ id, key, selection, }: {
+    addFieldSubscription({ id, key, selection, type, }: {
         id: string;
         key: string;
         selection: FieldSelection;
+        type: string;
     }): void;
     registerList({ list, id, key, parentType, selection, filters, variables, }: {
         list: Required<Required<SubscriptionSelection>['fields'][string]>['list'];

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

@@ -28,7 +28,8 @@ class InMemorySubscriptions {
       this.addFieldSubscription({
         id: parent,
         key,
-        selection: [spec, targetSelection2]
+        selection: [spec, targetSelection2],
+        type
       });
       if (list) {
         this.registerList({
@@ -65,7 +66,8 @@ class InMemorySubscriptions {
   addFieldSubscription({
     id,
     key,
-    selection
+    selection,
+    type
   }) {
     const spec = selection[0];
     if (!this.subscribers[id]) {
@@ -137,7 +139,8 @@ class InMemorySubscriptions {
         this.addFieldSubscription({
           id: parent,
           key,
-          selection: [spec, fieldSelection]
+          selection: [spec, fieldSelection],
+          type: linkedType
         });
         if (list) {
           this.registerList({

package/build/runtime-esm/client/documentStore.js

@@ -31,6 +31,7 @@ class DocumentStore extends Writable {
       data: initialValue ?? null,
       errors: null,
       partial: false,
+      stale: false,
       source: null,
       fetching,
       variables: null

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

@@ -23,7 +23,8 @@ const cachePolicyPlugin = ({
               data: value.data,
               errors: null,
               source: DataSource.Cache,
-              partial: value.partial
+              partial: value.partial,
+              stale: value.stale
             });
           }
           useCache = !!(value.data !== null && allowed);
@@ -34,10 +35,11 @@ const cachePolicyPlugin = ({
               data: value.data,
               errors: null,
               source: DataSource.Cache,
-              partial: value.partial
+              partial: value.partial,
+              stale: value.stale
             });
           }
-          if (useCache && !value.partial) {
+          if (useCache && !value.partial && !value.stale) {
             return;
           }
         }

package/build/runtime-esm/client/plugins/fetch.js

@@ -32,6 +32,7 @@ const fetchPlugin = (target) => {
           data: result.data,
           errors: !result.errors || result.errors.length === 0 ? null : result.errors,
           partial: false,
+          stale: false,
           source: DataSource.Network
         });
       }

package/build/runtime-esm/client/plugins/query.js

@@ -30,6 +30,7 @@ const queryPlugin = documentPlugin(ArtifactKind.Query, function() {
               errors: null,
               fetching: false,
               partial: false,
+              stale: false,
               source: DataSource.Cache,
               variables: ctx.variables ?? null
             });

package/build/runtime-esm/client/plugins/subscription.d.ts

@@ -1,4 +1,3 @@
-import type { GraphQLObject } from '../../lib/types';
 import type { ClientPluginContext } from '../documentStore';
 export declare function subscriptionPlugin(factory: SubscriptionHandler): import("../documentStore").ClientPlugin;
 export type SubscriptionHandler = (ctx: ClientPluginContext) => {
@@ -7,7 +6,7 @@ export type SubscriptionHandler = (ctx: ClientPluginContext) => {
         variables?: {};
     }, handlers: {
         next: (payload: {
-            data?: GraphQLObject;
+            data?: {} | null;
             errors?: readonly {
                 message: string;
             }[];

package/build/runtime-esm/client/plugins/subscription.js

@@ -43,6 +43,7 @@ function subscriptionPlugin(factory) {
                 errors: [...errors ?? []],
                 fetching: false,
                 partial: true,
+                stale: false,
                 source: DataSource.Network,
                 variables: ctx.variables ?? null
               });
@@ -51,6 +52,7 @@ function subscriptionPlugin(factory) {
               clearSubscription?.();
               resolve(ctx, {
                 partial: true,
+                stale: false,
                 source: DataSource.Network,
                 data: null,
                 errors: [data],

package/build/runtime-esm/lib/config.d.ts

@@ -55,6 +55,10 @@ export type ConfigFile = {
      * Specifies whether or not the cache should always use partial data. For more information: https://www.houdinigraphql.com/guides/caching-data#partial-data
      */
     defaultPartial?: boolean;
+    /**
+     * Specifies after how long a data goes stale in miliseconds. (default: `undefined`)
+     */
+    defaultLifetime?: number;
     /**
      * Specifies whether mutations should append or prepend list. For more information: https://www.houdinigraphql.com/api/graphql (default: `append`)
      */

package/build/runtime-esm/lib/index.d.ts

@@ -5,3 +5,4 @@ export * from './log';
 export * from './scalars';
 export * from './types';
 export * from './store';
+export * from './key';

package/build/runtime-esm/lib/index.js

@@ -5,3 +5,4 @@ export * from "./log";
 export * from "./scalars";
 export * from "./types";
 export * from "./store";
+export * from "./key";

package/build/runtime-esm/lib/key.d.ts

@@ -0,0 +1,6 @@
+export declare const computeKey: ({ field, args }: {
+    field: string;
+    args?: {
+        [key: string]: any;
+    } | undefined;
+}) => string;

package/build/runtime-esm/lib/key.js

@@ -0,0 +1,17 @@
+const computeKey = ({ field, args }) => {
+  const keys = Object.keys(args ?? {});
+  keys.sort();
+  return args && keys.length > 0 ? `${field}(${keys.map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(args[key])}`).join(", ")})` : field;
+};
+const stringifyObjectWithNoQuotesOnKeys = (obj_from_json) => {
+  if (Array.isArray(obj_from_json)) {
+    return `[${obj_from_json.map((obj) => `${stringifyObjectWithNoQuotesOnKeys(obj)}`).join(", ")}]`;
+  }
+  if (typeof obj_from_json !== "object" || obj_from_json instanceof Date || obj_from_json === null) {
+    return JSON.stringify(obj_from_json).replace(/"([^"]+)":/g, "$1: ");
+  }
+  return `{${Object.keys(obj_from_json).map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(obj_from_json[key])}`).join(", ")}}`;
+};
+export {
+  computeKey
+};

package/build/runtime-esm/lib/types.d.ts

@@ -80,7 +80,7 @@ export type BaseCompiledDocument = {
         paginated: boolean;
         direction: 'forward' | 'backward' | 'both';
     };
-    pluginsData?: Record<string, any>;
+    plugin_data?: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -164,7 +164,6 @@ export type SubscriptionSpec = {
 export type FetchQueryResult<_Data> = {
     result: RequestPayload<_Data | null>;
     source: DataSource | null;
-    partial: boolean;
 };
 export type QueryResult<_Data = GraphQLObject, _Input = Record<string, any>> = {
     data: _Data | null;
@@ -173,6 +172,7 @@ export type QueryResult<_Data = GraphQLObject, _Input = Record<string, any>> = {
     }[] | null;
     fetching: boolean;
     partial: boolean;
+    stale: boolean;
     source: DataSource | null;
     variables: _Input | null;
 };

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

@@ -2,7 +2,7 @@ import type { Cache as _Cache } from '../cache/cache';
 import { type QueryArtifact } from '../lib';
 import { ListCollection } from './list';
 import { Record } from './record';
-import type { CacheTypeDef, IDFields, QueryInput, QueryList, QueryValue, TypeNames, ValidLists } from './types';
+import type { ArgType, CacheTypeDef, IDFields, QueryInput, QueryList, QueryValue, TypeFieldNames, TypeNames, ValidLists } from './types';
 export declare class Cache<Def extends CacheTypeDef> {
     _internal_unstable: _Cache;
     constructor(cache: _Cache);
@@ -29,4 +29,11 @@ export declare class Cache<Def extends CacheTypeDef> {
         data: QueryValue<QueryList<Def>, _Query>;
         variables?: QueryInput<QueryList<Def>, _Query>;
     }): void;
+    /**
+     * Mark some elements of the cache stale.
+     */
+    markStale<_Type extends TypeNames<Def>, _Field extends TypeFieldNames<Def, _Type>>(type?: _Type, options?: {
+        field?: _Field;
+        when?: ArgType<Def, _Type, _Field>;
+    }): void;
 }

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

@@ -64,6 +64,9 @@ Please acknowledge this by setting acceptImperativeInstability to true in your c
     });
     return;
   }
+  markStale(type, options = {}) {
+    return this._internal_unstable.markTypeStale(type, options);
+  }
 }
 export {
   Cache

package/build/runtime-esm/public/record.d.ts

@@ -1,6 +1,6 @@
 import type { FragmentArtifact } from '../lib/types';
 import type { Cache } from './cache';
-import type { CacheTypeDef, FragmentList, FragmentValue, FragmentVariables, ValidTypes } from './types';
+import type { ArgType, CacheTypeDef, FragmentList, FragmentValue, FragmentVariables, TypeFieldNames, ValidTypes } from './types';
 export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
     #private;
     type: string;
@@ -26,6 +26,16 @@ export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<De
         fragment: _Fragment;
         data: FragmentValue<FragmentList<Def, Type>, _Fragment>;
         variables?: FragmentVariables<FragmentList<Def, Type>, _Fragment>;
+        forceStale?: boolean;
     }): void;
     delete(): void;
+    /**
+     * Mark some elements of the record stale in the cache.
+     * @param field
+     * @param when
+     */
+    markStale<Field extends TypeFieldNames<Def, Type>>({ field, when, }?: {
+        field?: Field;
+        when?: ArgType<Def, Type, Field>;
+    }): void;
 }

package/build/runtime-esm/public/record.js

@@ -47,12 +47,19 @@ class Record {
         config: this.#cache.config,
         artifact: args.fragment.artifact,
         input: args.variables
-      }) ?? void 0
+      }) ?? void 0,
+      forceStale: args.forceStale
     });
   }
   delete() {
     this.#cache._internal_unstable.delete(this.#id);
   }
+  markStale({
+    field,
+    when
+  } = {}) {
+    this.#cache._internal_unstable.markRecordStale(this.#id, { field, when });
+  }
 }
 export {
   Record

package/build/runtime-esm/public/tests/test.d.ts

@@ -1,7 +1,7 @@
 import { type SubscriptionSelection, type FragmentArtifact, type QueryArtifact } from '../../lib';
 import { Cache } from '../cache';
 import type { Record } from '../record';
-type CacheTypeDef = {
+export type CacheTypeDefTest = {
     types: {
         __ROOT__: {
             idFields: {};
@@ -16,23 +16,23 @@ type CacheTypeDef = {
                     args: never;
                 };
                 viewer: {
-                    type: Record<CacheTypeDef, 'User'> | null;
+                    type: Record<CacheTypeDefTest, 'User'> | null;
                     args: never;
                 };
                 pets: {
-                    type: (Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'>)[];
+                    type: (Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'>)[];
                     args: never;
                 };
                 listOfLists: {
-                    type: ((Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'> | null | (null | Record<CacheTypeDef, 'User'>)[])[] | Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'> | null)[];
+                    type: ((Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'> | null | (null | Record<CacheTypeDefTest, 'User'>)[])[] | Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'> | null)[];
                     args: never;
                 };
                 users: {
-                    type: Record<CacheTypeDef, 'User'>[] | null;
+                    type: Record<CacheTypeDefTest, 'User'>[] | null;
                     args: never;
                 };
                 pet: {
-                    type: Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'>;
+                    type: Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'>;
                     args: never;
                 };
             };
@@ -60,7 +60,7 @@ type CacheTypeDef = {
                     args: never;
                 };
                 parent: {
-                    type: Record<CacheTypeDef, 'User'>;
+                    type: Record<CacheTypeDefTest, 'User'>;
                     args: never;
                 };
                 id: {
@@ -84,7 +84,7 @@ type CacheTypeDef = {
                     args: never;
                 };
                 parent: {
-                    type: Record<CacheTypeDef, 'User'> | null;
+                    type: Record<CacheTypeDefTest, 'User'> | null;
                     args: never;
                 };
                 id: {
@@ -147,11 +147,10 @@ type CacheTypeDef = {
         };
     };
 };
-export declare const testCache: () => Cache<CacheTypeDef>;
+export declare const testCache: () => Cache<CacheTypeDefTest>;
 export declare const testFragment: (selection: SubscriptionSelection) => {
     artifact: FragmentArtifact;
 };
 export declare const testQuery: (selection: SubscriptionSelection) => {
     artifact: QueryArtifact;
 };
-export {};