houdini 1.0.0-next.3 → 1.0.0-next.5

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

@@ -4,9 +4,10 @@ import { GarbageCollector } from './gc';
 import type { ListCollection } from './lists';
 import { ListManager } from './lists';
 import { SchemaManager } from './schema';
+import { StaleManager } from './staleManager';
 import type { Layer, LayerID } from './storage';
 import { InMemoryStorage } from './storage';
-import { type FieldSelection, InMemorySubscriptions } from './subscription';
+import { InMemorySubscriptions, type FieldSelection } from './subscription';
 export declare class Cache {
     _internal_unstable: CacheInternal;
     constructor(config?: ConfigFile);
@@ -18,19 +19,30 @@ 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(type?: string, options?: {
+        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;
@@ -40,17 +52,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;
         };
@@ -62,8 +76,9 @@ declare class CacheInternal {
         root?: string;
         layer: Layer;
         toNotify?: FieldSelection[];
-        applyUpdates?: boolean;
+        applyUpdates?: string[];
         forceNotify?: boolean;
+        forceStale?: boolean;
     }): FieldSelection[];
     getSelection({ selection, parent, variables, stepsFromConnection, }: {
         selection: SubscriptionSelection;
@@ -73,6 +88,7 @@ declare class CacheInternal {
     }): {
         data: GraphQLObject | null;
         partial: boolean;
+        stale: boolean;
         hasData: boolean;
     };
     id(type: string, data: {} | null): string | null;
@@ -87,6 +103,7 @@ declare class CacheInternal {
     }): {
         data: LinkedList<GraphQLValue>;
         partial: boolean;
+        stale: boolean;
         hasData: boolean;
     };
     extractNestedListIDs({ value, abstract, recordID, key, linkedType, fields, variables, applyUpdates, specs, layer, forceNotify, }: {
@@ -97,7 +114,7 @@ declare class CacheInternal {
         abstract: boolean;
         variables: {};
         specs: FieldSelection[];
-        applyUpdates: boolean;
+        applyUpdates?: string[];
         fields: SubscriptionSelection;
         layer: Layer;
         forceNotify?: boolean;

package/build/runtime/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/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/client/documentStore.d.ts

@@ -53,7 +53,7 @@ export type ClientPluginContext = {
         forceNotify?: boolean;
         disableWrite?: boolean;
         disableRead?: boolean;
-        applyUpdates?: boolean;
+        applyUpdates?: string[];
     };
     stuff: App.Stuff;
 };

package/build/runtime/client/plugins/fetchParams.d.ts

@@ -5,5 +5,5 @@ export declare const fetchParamsPlugin: (fn?: FetchParamFn) => ClientPlugin;
 export type FetchParamsInput = Pick<ClientPluginContext, 'config' | 'policy' | 'variables' | 'metadata' | 'session' | 'stuff'> & {
     text: string;
     hash: string;
-    artifact: DocumentArtifact;
+    document: DocumentArtifact;
 };

package/build/runtime/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/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/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/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/lib/types.d.ts

@@ -71,7 +71,6 @@ export type BaseCompiledDocument = {
     rootType: string;
     input?: InputObject;
     refetch?: {
-        update: RefetchUpdateMode;
         path: string[];
         method: 'cursor' | 'offset';
         pageSize: number;
@@ -79,9 +78,9 @@ export type BaseCompiledDocument = {
         embedded: boolean;
         targetType: string;
         paginated: boolean;
-        direction?: 'forward' | 'backwards';
+        direction: 'forward' | 'backward' | 'both';
     };
-    pluginsData?: Record<string, any>;
+    plugin_data?: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -135,7 +134,7 @@ export type SubscriptionSelection = {
                 connection: boolean;
                 type: string;
             };
-            update?: RefetchUpdateMode;
+            updates?: string[];
             filters?: {
                 [key: string]: {
                     kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Variable';
@@ -165,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;
@@ -174,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/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/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/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 {};

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

@@ -4,9 +4,10 @@ import { GarbageCollector } from './gc';
 import type { ListCollection } from './lists';
 import { ListManager } from './lists';
 import { SchemaManager } from './schema';
+import { StaleManager } from './staleManager';
 import type { Layer, LayerID } from './storage';
 import { InMemoryStorage } from './storage';
-import { type FieldSelection, InMemorySubscriptions } from './subscription';
+import { InMemorySubscriptions, type FieldSelection } from './subscription';
 export declare class Cache {
     _internal_unstable: CacheInternal;
     constructor(config?: ConfigFile);
@@ -18,19 +19,30 @@ 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(type?: string, options?: {
+        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;
@@ -40,17 +52,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;
         };
@@ -62,8 +76,9 @@ declare class CacheInternal {
         root?: string;
         layer: Layer;
         toNotify?: FieldSelection[];
-        applyUpdates?: boolean;
+        applyUpdates?: string[];
         forceNotify?: boolean;
+        forceStale?: boolean;
     }): FieldSelection[];
     getSelection({ selection, parent, variables, stepsFromConnection, }: {
         selection: SubscriptionSelection;
@@ -73,6 +88,7 @@ declare class CacheInternal {
     }): {
         data: GraphQLObject | null;
         partial: boolean;
+        stale: boolean;
         hasData: boolean;
     };
     id(type: string, data: {} | null): string | null;
@@ -87,6 +103,7 @@ declare class CacheInternal {
     }): {
         data: LinkedList<GraphQLValue>;
         partial: boolean;
+        stale: boolean;
         hasData: boolean;
     };
     extractNestedListIDs({ value, abstract, recordID, key, linkedType, fields, variables, applyUpdates, specs, layer, forceNotify, }: {
@@ -97,7 +114,7 @@ declare class CacheInternal {
         abstract: boolean;
         variables: {};
         specs: FieldSelection[];
-        applyUpdates: boolean;
+        applyUpdates?: string[];
         fields: SubscriptionSelection;
         layer: Layer;
         forceNotify?: boolean;