houdini 1.0.0-next.1 → 1.0.0-next.2

package/build/runtime-cjs/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-cjs/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;

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

@@ -282,11 +282,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,

package/build/runtime-cjs/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-cjs/cache/stuff.d.ts

@@ -1,5 +1,5 @@
-import { GraphQLValue } from '../lib/types';
-import { LinkedList } from './cache';
+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;

package/build/runtime-cjs/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,27 @@ export declare class InMemorySubscriptions {
             [key: string]: GraphQLValue;
         };
     }): void;
-    addFieldSubscription({ id, key, field, spec, parentType, variables, }: {
+    addFieldSubscription({ id, key, selection, }: {
         id: string;
         key: string;
-        field: Required<SubscriptionSelection>['fields'][string];
-        spec: SubscriptionSpec;
+        selection: FieldSelection;
+    }): 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-cjs/cache/subscription.js

@@ -41,16 +41,29 @@ class InMemorySubscriptions {
     const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
     let targetSelection = (0, import_selection.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 = (0, import_stuff.evaluateKey)(keyRaw, variables);
+      let targetSelection2;
+      if (innerSelection) {
+        const __typename2 = this.cache._internal_unstable.storage.get(parent, "__typename").value;
+        targetSelection2 = (0, import_selection.getFieldsForType)(innerSelection, __typename2);
+      }
       this.addFieldSubscription({
         id: parent,
         key,
-        field: fieldSelection,
-        spec,
-        parentType: parentType || spec.rootType,
-        variables
+        selection: [spec, targetSelection2]
       });
+      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,
@@ -75,11 +88,9 @@ class InMemorySubscriptions {
   addFieldSubscription({
     id,
     key,
-    field,
-    spec,
-    parentType,
-    variables
+    selection
   }) {
+    const spec = selection[0];
     if (!this.subscribers[id]) {
       this.subscribers[id] = {};
     }
@@ -90,8 +101,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] = {};
@@ -102,61 +113,87 @@ 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 = (0, import_selection.getFieldsForType)(selection, parentType);
-    for (const fieldSelection of Object.values(targetSelection)) {
-      const { type: linkedType, keyRaw, selection: innerSelection } = fieldSelection;
-      const key = (0, import_stuff.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 = (0, import_stuff.evaluateKey)(keyRaw, variables);
+        const fieldSelection = innerSelection ? (0, import_selection.getFieldsForType)(innerSelection, parentType) : void 0;
         this.addFieldSubscription({
           id: parent,
           key,
-          field: fieldSelection,
-          spec,
-          parentType,
-          variables
+          selection: [spec, fieldSelection]
         });
-      }
-      if (innerSelection) {
-        const { value: link } = this.cache._internal_unstable.storage.get(parent, key);
-        const children = !Array.isArray(link) ? [link] : (0, import_stuff.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] : (0, import_stuff.flattenList)(link);
+          for (const linkedRecord of children) {
+            if (!linkedRecord) {
+              continue;
+            }
+            const __typename = this.cache._internal_unstable.storage.get(
+              linkedRecord,
+              "__typename"
+            ).value;
+            let targetSelection2 = (0, import_selection.getFieldsForType)(childSelection, __typename);
+            this.addMany({
+              parent: linkedRecord,
+              variables,
+              subscribers: subscribers.map(([sub]) => [sub, targetSelection2]),
+              parentType: linkedType
+            });
+          }
+        }
       }
     }
   }
@@ -166,10 +203,12 @@ 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 = (0, import_selection.getFieldsForType)(selection, __typename);
+    for (const fieldSelection of Object.values(targetSelection || {})) {
       const key = (0, import_stuff.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);
@@ -200,14 +239,14 @@ 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") {

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

@@ -0,0 +1,87 @@
+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?: ClientPlugin[];
+        pipeline?: ClientPlugin[];
+        client: HoudiniClient;
+        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 = () => {
+    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?: boolean;
+    };
+    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 {};