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

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/storage.d.ts

@@ -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 }: {
@@ -52,14 +52,14 @@ export declare class Layer {
     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,7 +69,7 @@ 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;

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

@@ -1,4 +1,4 @@
-import { flattenList } from "./stuff";
+import { flatten } from "../lib/flatten";
 class InMemoryStorage {
   data;
   idCount = 0;
@@ -198,7 +198,7 @@ class Layer {
   }
   writeLink(id, field, value) {
     const valueList = Array.isArray(value) ? value : [value];
-    for (const value2 of flattenList(valueList)) {
+    for (const value2 of flatten(valueList)) {
       if (!value2) {
         continue;
       }

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

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

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

@@ -1,18 +1,3 @@
-function flattenList(source) {
-  const flat = [];
-  const unvisited = [source || []];
-  while (unvisited.length > 0) {
-    const target = unvisited.shift();
-    for (const id of target) {
-      if (Array.isArray(id)) {
-        unvisited.push(id);
-        continue;
-      }
-      flat.push(id);
-    }
-  }
-  return flat;
-}
 function evaluateKey(key, variables = {}) {
   let evaluated = "";
   let varName = "";
@@ -40,6 +25,5 @@ function evaluateKey(key, variables = {}) {
 }
 const varChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789";
 export {
-  evaluateKey,
-  flattenList
+  evaluateKey
 };

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

@@ -1,6 +1,9 @@
-import type { SubscriptionSpec, SubscriptionSelection, GraphQLObject } from '../lib/types';
-import type { GraphQLValue } from '../lib/types';
-import { Cache } from './cache';
+import type { GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
+import type { Cache } from './cache';
+export type FieldSelection = [
+    SubscriptionSpec,
+    Required<SubscriptionSelection>['fields'] | undefined
+];
 export declare class InMemorySubscriptions {
     private cache;
     constructor(cache: Cache);
@@ -16,22 +19,28 @@ export declare class InMemorySubscriptions {
             [key: string]: GraphQLValue;
         };
     }): void;
-    addFieldSubscription({ id, key, field, spec, parentType, variables, }: {
+    addFieldSubscription({ id, key, selection, type, }: {
         id: string;
         key: string;
-        field: Required<SubscriptionSelection>['fields'][string];
-        spec: SubscriptionSpec;
+        selection: FieldSelection;
+        type: string;
+    }): void;
+    registerList({ list, id, key, parentType, selection, filters, variables, }: {
+        list: Required<Required<SubscriptionSelection>['fields'][string]>['list'];
+        selection: SubscriptionSelection;
+        id: string;
         parentType: string;
-        variables: GraphQLObject;
+        key: string;
+        filters: Required<SubscriptionSelection>['fields'][string]['filters'];
+        variables: Record<string, any>;
     }): void;
-    addMany({ parent, selection, variables, subscribers, parentType, }: {
+    addMany({ parent, variables, subscribers, parentType, }: {
         parent: string;
-        selection: SubscriptionSelection;
         variables: {};
-        subscribers: SubscriptionSpec[];
+        subscribers: FieldSelection[];
         parentType: string;
     }): void;
-    get(id: string, field: string): SubscriptionSpec[];
+    get(id: string, field: string): FieldSelection[];
     remove(id: string, selection: SubscriptionSelection, targets: SubscriptionSpec[], variables: {}, visited?: string[]): void;
     private removeSubscribers;
     removeAllSubscribers(id: string, targets?: SubscriptionSpec[], visited?: string[]): void;

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

@@ -1,5 +1,6 @@
+import { flatten } from "../lib/flatten";
 import { getFieldsForType } from "../lib/selection";
-import { evaluateKey, flattenList } from "./stuff";
+import { evaluateKey } from "./stuff";
 class InMemorySubscriptions {
   cache;
   constructor(cache) {
@@ -18,22 +19,36 @@ class InMemorySubscriptions {
     const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
     let targetSelection = getFieldsForType(selection, __typename);
     for (const fieldSelection of Object.values(targetSelection || {})) {
-      const { keyRaw, selection: innerSelection, type } = fieldSelection;
+      const { keyRaw, selection: innerSelection, type, list, filters } = fieldSelection;
       const key = evaluateKey(keyRaw, variables);
+      let targetSelection2;
+      if (innerSelection) {
+        const __typename2 = this.cache._internal_unstable.storage.get(parent, "__typename").value;
+        targetSelection2 = getFieldsForType(innerSelection, __typename2);
+      }
       this.addFieldSubscription({
         id: parent,
         key,
-        field: fieldSelection,
-        spec,
-        parentType: parentType || spec.rootType,
-        variables
+        selection: [spec, targetSelection2],
+        type
       });
+      if (list) {
+        this.registerList({
+          list,
+          filters,
+          id: parent,
+          key,
+          variables,
+          selection: innerSelection,
+          parentType: parentType || spec.rootType
+        });
+      }
       if (innerSelection) {
         const { value: linkedRecord } = this.cache._internal_unstable.storage.get(
           parent,
           key
         );
-        let children = !Array.isArray(linkedRecord) ? [linkedRecord] : flattenList(linkedRecord) || [];
+        let children = !Array.isArray(linkedRecord) ? [linkedRecord] : flatten(linkedRecord) || [];
         for (const child of children) {
           if (!child) {
             continue;
@@ -52,11 +67,10 @@ class InMemorySubscriptions {
   addFieldSubscription({
     id,
     key,
-    field,
-    spec,
-    parentType,
-    variables
+    selection,
+    type
   }) {
+    const spec = selection[0];
     if (!this.subscribers[id]) {
       this.subscribers[id] = {};
     }
@@ -67,8 +81,8 @@ class InMemorySubscriptions {
       this.keyVersions[key] = /* @__PURE__ */ new Set();
     }
     this.keyVersions[key].add(key);
-    if (!this.subscribers[id][key].map(({ set }) => set).includes(spec.set)) {
-      this.subscribers[id][key].push(spec);
+    if (!this.subscribers[id][key].map(([{ set }]) => set).includes(spec.set)) {
+      this.subscribers[id][key].push([spec, selection[1]]);
     }
     if (!this.referenceCounts[id]) {
       this.referenceCounts[id] = {};
@@ -79,61 +93,88 @@ class InMemorySubscriptions {
     const counts = this.referenceCounts[id][key];
     counts.set(spec.set, (counts.get(spec.set) || 0) + 1);
     this.cache._internal_unstable.lifetimes.resetLifetime(id, key);
-    const { selection, list, filters } = field;
-    if (selection && list) {
-      this.cache._internal_unstable.lists.add({
-        name: list.name,
-        connection: list.connection,
-        recordID: id,
-        recordType: this.cache._internal_unstable.storage.get(id, "__typename")?.value || parentType,
-        listType: list.type,
-        key,
-        selection,
-        filters: Object.entries(filters || {}).reduce((acc, [key2, { kind, value }]) => {
-          return {
-            ...acc,
-            [key2]: kind !== "Variable" ? value : variables[value]
-          };
-        }, {})
-      });
-    }
+    const { selection: innerSelection } = selection[1]?.[key] ?? {};
+  }
+  registerList({
+    list,
+    id,
+    key,
+    parentType,
+    selection,
+    filters,
+    variables
+  }) {
+    this.cache._internal_unstable.lists.add({
+      name: list.name,
+      connection: list.connection,
+      recordID: id,
+      recordType: this.cache._internal_unstable.storage.get(id, "__typename")?.value || parentType,
+      listType: list.type,
+      key,
+      selection,
+      filters: Object.entries(filters || {}).reduce((acc, [key2, { kind, value }]) => {
+        return {
+          ...acc,
+          [key2]: kind !== "Variable" ? value : variables[value]
+        };
+      }, {})
+    });
   }
   addMany({
     parent,
-    selection,
     variables,
     subscribers,
     parentType
   }) {
-    let targetSelection = getFieldsForType(selection, parentType);
-    for (const fieldSelection of Object.values(targetSelection)) {
-      const { type: linkedType, keyRaw, selection: innerSelection } = fieldSelection;
-      const key = evaluateKey(keyRaw, variables);
-      for (const spec of subscribers) {
+    for (const [spec, targetSelection] of subscribers) {
+      for (const selection of Object.values(targetSelection ?? {})) {
+        const {
+          type: linkedType,
+          keyRaw,
+          selection: innerSelection,
+          list,
+          filters
+        } = selection;
+        const key = evaluateKey(keyRaw, variables);
+        const fieldSelection = innerSelection ? getFieldsForType(innerSelection, parentType) : void 0;
         this.addFieldSubscription({
           id: parent,
           key,
-          field: fieldSelection,
-          spec,
-          parentType,
-          variables
+          selection: [spec, fieldSelection],
+          type: linkedType
         });
-      }
-      if (innerSelection) {
-        const { value: link } = this.cache._internal_unstable.storage.get(parent, key);
-        const children = !Array.isArray(link) ? [link] : flattenList(link);
-        for (const linkedRecord of children) {
-          if (!linkedRecord) {
-            continue;
-          }
-          this.addMany({
-            parent: linkedRecord,
-            selection: innerSelection,
+        if (list) {
+          this.registerList({
+            list,
+            filters,
+            id: parent,
+            key,
             variables,
-            subscribers,
-            parentType: linkedType
+            selection: innerSelection,
+            parentType: parentType || spec.rootType
           });
         }
+        const childSelection = selection.selection;
+        if (childSelection) {
+          const { value: link } = this.cache._internal_unstable.storage.get(parent, key);
+          const children = !Array.isArray(link) ? [link] : flatten(link);
+          for (const linkedRecord of children) {
+            if (!linkedRecord) {
+              continue;
+            }
+            const __typename = this.cache._internal_unstable.storage.get(
+              linkedRecord,
+              "__typename"
+            ).value;
+            let targetSelection2 = getFieldsForType(childSelection, __typename);
+            this.addMany({
+              parent: linkedRecord,
+              variables,
+              subscribers: subscribers.map(([sub]) => [sub, targetSelection2]),
+              parentType: linkedType
+            });
+          }
+        }
       }
     }
   }
@@ -143,14 +184,16 @@ class InMemorySubscriptions {
   remove(id, selection, targets, variables, visited = []) {
     visited.push(id);
     const linkedIDs = [];
-    for (const fieldSelection of Object.values(selection.fields || {})) {
+    const __typename = this.cache._internal_unstable.storage.get(id, "__typename").value;
+    let targetSelection = getFieldsForType(selection, __typename);
+    for (const fieldSelection of Object.values(targetSelection || {})) {
       const key = evaluateKey(fieldSelection.keyRaw, variables);
       this.removeSubscribers(id, key, targets);
-      if (!fieldSelection.selection?.fields) {
+      if (!fieldSelection.selection) {
         continue;
       }
       const { value: previousValue } = this.cache._internal_unstable.storage.get(id, key);
-      const links = !Array.isArray(previousValue) ? [previousValue] : flattenList(previousValue);
+      const links = !Array.isArray(previousValue) ? [previousValue] : flatten(previousValue);
       for (const link of links) {
         if (link !== null) {
           linkedIDs.push([link, fieldSelection.selection || {}]);
@@ -177,20 +220,20 @@ class InMemorySubscriptions {
     }
     if (this.subscribers[id]) {
       this.subscribers[id][fieldName] = this.get(id, fieldName).filter(
-        ({ set }) => !targets.includes(set)
+        ([{ set }]) => !targets.includes(set)
       );
     }
   }
   removeAllSubscribers(id, targets, visited = []) {
     visited.push(id);
     for (const field of Object.keys(this.subscribers[id] || [])) {
-      const subscribers = targets || this.subscribers[id][field];
+      const subscribers = targets || this.subscribers[id][field].map(([spec]) => spec);
       this.removeSubscribers(id, field, subscribers);
       const { value, kind } = this.cache._internal_unstable.storage.get(id, field);
       if (kind === "scalar") {
         continue;
       }
-      const nextTargets = Array.isArray(value) ? flattenList(value) : [value];
+      const nextTargets = Array.isArray(value) ? flatten(value) : [value];
       for (const id2 of nextTargets) {
         if (visited.includes(id2)) {
           continue;

package/build/runtime-esm/client/documentStore.d.ts

@@ -0,0 +1,88 @@
+import type { HoudiniClient } from '.';
+import type { Layer } from '../cache/storage';
+import type { ConfigFile } from '../lib/config';
+import { Writable } from '../lib/store';
+import type { CachePolicy, DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec } from '../lib/types';
+export declare class DocumentStore<_Data extends GraphQLObject, _Input extends Record<string, any>> extends Writable<QueryResult<_Data, _Input>> {
+    #private;
+    constructor({ artifact, plugins, pipeline, client, cache, initialValue, fetching, }: {
+        artifact: DocumentArtifact;
+        plugins?: ClientHooks[];
+        pipeline?: ClientHooks[];
+        client: HoudiniClient | null;
+        cache?: boolean;
+        initialValue?: _Data | null;
+        fetching?: boolean;
+    });
+    send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, }?: {
+        fetch?: Fetch;
+        variables?: Record<string, any> | null;
+        metadata?: App.Metadata | null;
+        session?: App.Session | null;
+        policy?: CachePolicy;
+        stuff?: Partial<App.Stuff>;
+        cacheParams?: ClientPluginContext['cacheParams'];
+        setup?: boolean;
+    }): Promise<QueryResult<_Data, _Input>>;
+}
+declare function marshalVariables<_Data extends GraphQLObject, _Input extends {}>(ctx: ClientPluginContext): Record<string, any>;
+export type ClientPlugin = () => ClientHooks | null | (ClientHooks | ClientPlugin | null)[];
+export type ClientHooks = {
+    start?: ClientPluginEnterPhase;
+    beforeNetwork?: ClientPluginEnterPhase;
+    network?: ClientPluginEnterPhase;
+    afterNetwork?: ClientPluginExitPhase;
+    end?: ClientPluginExitPhase;
+    cleanup?(ctx: ClientPluginContext): void | Promise<void>;
+    catch?(ctx: ClientPluginContext, args: ClientPluginErrorHandlers): void | Promise<void>;
+};
+export type Fetch = typeof globalThis.fetch;
+export type ClientPluginContext = {
+    config: ConfigFile;
+    text: string;
+    hash: string;
+    artifact: DocumentArtifact;
+    policy?: CachePolicy;
+    fetch?: Fetch;
+    variables?: Record<string, any>;
+    metadata?: App.Metadata | null;
+    session?: App.Session | null;
+    fetchParams?: RequestInit;
+    cacheParams?: {
+        layer?: Layer;
+        notifySubscribers?: SubscriptionSpec[];
+        forceNotify?: boolean;
+        disableWrite?: boolean;
+        disableRead?: boolean;
+        applyUpdates?: string[];
+    };
+    stuff: App.Stuff;
+};
+type ClientPluginPhase<Handlers> = (ctx: ClientPluginContext, handlers: Handlers) => void | Promise<void>;
+export type ClientPluginEnterPhase = ClientPluginPhase<ClientPluginEnterHandlers>;
+export type ClientPluginExitPhase = ClientPluginPhase<ClientPluginExitHandlers>;
+export type ClientPluginEnterHandlers = {
+    initialValue: QueryResult;
+    /** A reference to the houdini client to access any configuration values */
+    client: HoudiniClient;
+    /** Move onto the next step using the provided context.  */
+    next(ctx: ClientPluginContext): void;
+    /** Terminate the current chain  */
+    resolve(ctx: ClientPluginContext, data: QueryResult): void;
+    /** Update the stores state without resolving the promise */
+    updateState(updater: (old: QueryResult) => QueryResult): void;
+    /** Return true if the variables have changed */
+    variablesChanged: (ctx: ClientPluginContext) => boolean;
+    /** Returns the marshaled variables for the operation */
+    marshalVariables: typeof marshalVariables;
+};
+/** Exit handlers are the same as enter handles but don't need to resolve with a specific value */
+export type ClientPluginExitHandlers = Omit<ClientPluginEnterHandlers, 'resolve'> & {
+    resolve: (ctx: ClientPluginContext, data?: QueryResult) => void;
+    value: QueryResult;
+};
+/** Exit handlers are the same as enter handles but don't need to resolve with a specific value */
+export type ClientPluginErrorHandlers = ClientPluginEnterHandlers & {
+    error: unknown;
+};
+export {};