houdini 1.0.0-next.1 → 1.0.0-next.3

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

@@ -18,16 +18,29 @@ 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]
       });
+      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,
@@ -52,11 +65,9 @@ class InMemorySubscriptions {
   addFieldSubscription({
     id,
     key,
-    field,
-    spec,
-    parentType,
-    variables
+    selection
   }) {
+    const spec = selection[0];
     if (!this.subscribers[id]) {
       this.subscribers[id] = {};
     }
@@ -67,8 +78,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 +90,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 = 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]
         });
-      }
-      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] : flattenList(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,10 +180,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 = 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);
@@ -177,14 +216,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-esm/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 {};

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

@@ -0,0 +1,336 @@
+import { getCurrentConfig } from "../lib/config";
+import { deepEquals } from "../lib/deepEquals";
+import { marshalInputs, unmarshalSelection } from "../lib/scalars";
+import { Writable } from "../lib/store";
+import { ArtifactKind } from "../lib/types";
+import { cachePolicyPlugin } from "./plugins";
+const steps = {
+  forward: ["start", "beforeNetwork", "network"],
+  backwards: ["end", "afterNetwork"]
+};
+class DocumentStore extends Writable {
+  #artifact;
+  #client;
+  #configFile;
+  #plugins;
+  #lastVariables;
+  #lastContext = null;
+  constructor({
+    artifact,
+    plugins,
+    pipeline,
+    client,
+    cache = true,
+    initialValue,
+    fetching
+  }) {
+    if (fetching === void 0) {
+      fetching = artifact.kind === ArtifactKind.Query;
+    }
+    const initialState = {
+      data: initialValue ?? null,
+      errors: null,
+      partial: false,
+      source: null,
+      fetching,
+      variables: null
+    };
+    super(initialState, () => {
+      return () => {
+        this.#lastVariables = null;
+        for (const plugin of this.#plugins) {
+          plugin.cleanup?.(this.#lastContext);
+        }
+      };
+    });
+    this.#artifact = artifact;
+    this.#client = client;
+    this.#lastVariables = null;
+    this.#configFile = getCurrentConfig();
+    this.#plugins = (pipeline ?? [
+      cachePolicyPlugin({
+        enabled: cache,
+        setFetching: (fetching2) => this.update((state) => ({ ...state, fetching: fetching2 }))
+      }),
+      ...plugins ?? []
+    ]).map((factory) => factory());
+  }
+  async send({
+    metadata,
+    session,
+    fetch = globalThis.fetch,
+    variables,
+    policy,
+    stuff,
+    cacheParams,
+    setup = false
+  } = {}) {
+    let context = new ClientPluginContextWrapper({
+      config: this.#configFile,
+      text: this.#artifact.raw,
+      hash: this.#artifact.hash,
+      policy: policy ?? this.#artifact.policy,
+      variables: {},
+      metadata,
+      session,
+      fetch,
+      stuff: {
+        inputs: {
+          changed: false,
+          init: false,
+          marshaled: {}
+        },
+        ...stuff
+      },
+      artifact: this.#artifact,
+      lastVariables: this.#lastVariables,
+      cacheParams
+    });
+    const draft = context.draft();
+    draft.variables = variables ?? {};
+    context = context.apply(draft, false);
+    return await new Promise((resolve, reject) => {
+      const state = {
+        setup,
+        currentStep: 0,
+        index: 0,
+        promise: {
+          resolved: false,
+          resolve,
+          reject
+        },
+        context
+      };
+      this.#step("forward", state);
+    });
+  }
+  #step(direction, ctx, value) {
+    const hook = direction === "error" ? "catch" : steps[direction][ctx.currentStep];
+    let valid = (i) => i <= this.#plugins.length;
+    let step = (i) => i + 1;
+    if (["backwards", "error"].includes(direction)) {
+      valid = (i) => i >= 0;
+      step = (i) => i - 1;
+    }
+    for (let index = ctx.index; valid(index); index = step(index)) {
+      let target = this.#plugins[index]?.[hook];
+      if (!target) {
+        continue;
+      }
+      const draft = ctx.context.draft();
+      let variablesRefChanged = (newContext) => newContext.variables !== draft.variables;
+      const common = {
+        initialValue: this.state,
+        client: this.#client,
+        variablesChanged,
+        marshalVariables,
+        updateState: this.update.bind(this),
+        next: (newContext) => {
+          const nextIndex = ["forward", "error"].includes(direction) ? index + 1 : index;
+          const nextStep = ["backwards", "error"].includes(direction) ? 0 : ctx.currentStep;
+          this.#step("forward", {
+            ...ctx,
+            index: nextIndex,
+            currentStep: nextStep,
+            context: ctx.context.apply(newContext, variablesRefChanged(newContext))
+          });
+        },
+        resolve: (newContext, value2) => {
+          const nextIndex = direction === "backwards" ? index - 1 : index;
+          this.#step(
+            "backwards",
+            {
+              ...ctx,
+              index: nextIndex,
+              context: ctx.context.apply(newContext, variablesRefChanged(newContext))
+            },
+            value2
+          );
+        }
+      };
+      let handlers;
+      if (direction === "forward") {
+        handlers = common;
+      } else if (direction === "backwards") {
+        handlers = {
+          ...common,
+          value,
+          resolve: (ctx2, data2) => {
+            return common.resolve(ctx2, data2 ?? value);
+          }
+        };
+      } else if (direction === "error") {
+        handlers = {
+          ...common,
+          error: value
+        };
+      }
+      try {
+        const result = target(draft, handlers);
+        result?.catch((err) => {
+          this.#step("error", { ...ctx, index: index - 1 }, err);
+        });
+      } catch (err) {
+        this.#step("error", { ...ctx, index: index - 1 }, err);
+      }
+      return;
+    }
+    if (direction === "forward") {
+      if (ctx.setup) {
+        return this.#step(
+          "backwards",
+          {
+            ...ctx,
+            currentStep: 0,
+            index: this.#plugins.length
+          },
+          this.state
+        );
+      }
+      if (ctx.currentStep <= steps.forward.length - 2) {
+        return this.#step("forward", {
+          ...ctx,
+          currentStep: ctx.currentStep + 1,
+          index: 0
+        });
+      }
+      throw new Error(
+        "Called next() on last possible plugin. Your chain is missing a plugin that calls resolve()."
+      );
+    }
+    if (direction === "error") {
+      if (!ctx.promise.resolved) {
+        ctx.promise.reject(value);
+        ctx.promise.resolved = true;
+      }
+      return;
+    }
+    if (ctx.currentStep > 0) {
+      return this.#step(
+        "backwards",
+        {
+          ...ctx,
+          currentStep: ctx.currentStep - 1,
+          index: this.#plugins.length - 1
+        },
+        value
+      );
+    }
+    let data = value.data;
+    try {
+      data = unmarshalSelection(this.#configFile, this.#artifact.selection, data) ?? null;
+    } catch {
+    }
+    const finalValue = {
+      ...value,
+      data
+    };
+    if (!ctx.promise.resolved) {
+      ctx.promise.resolve(finalValue);
+      ctx.promise.resolved = true;
+    }
+    this.#lastContext = ctx.context.draft();
+    this.#lastVariables = this.#lastContext.stuff.inputs.marshaled;
+    this.set(finalValue);
+  }
+}
+class ClientPluginContextWrapper {
+  #context;
+  #lastVariables;
+  constructor({
+    lastVariables,
+    ...values
+  }) {
+    this.#context = values;
+    this.#lastVariables = lastVariables;
+  }
+  get variables() {
+    return this.#context.variables;
+  }
+  draft() {
+    const ctx = {
+      ...this.#context
+    };
+    const applyVariables = this.applyVariables.bind(this);
+    return {
+      ...ctx,
+      get stuff() {
+        return ctx.stuff;
+      },
+      set stuff(val) {
+        ctx.stuff = val;
+      },
+      get variables() {
+        return ctx.variables ?? {};
+      },
+      set variables(val) {
+        Object.assign(ctx, applyVariables(ctx, { variables: val }));
+      }
+    };
+  }
+  applyVariables(source, values) {
+    const artifact = source.artifact;
+    const ctx = {
+      ...source,
+      ...values
+    };
+    const val = values.variables;
+    let changed = {};
+    for (const [name, value] of Object.entries(val ?? {})) {
+      if (value !== source.variables?.[name]) {
+        changed[name] = value;
+      }
+    }
+    ctx.stuff = {
+      ...ctx.stuff,
+      inputs: {
+        ...ctx.stuff.inputs
+      }
+    };
+    const firstInit = !ctx.stuff.inputs || !ctx.stuff.inputs.init;
+    const hasChanged = Object.keys(changed).length > 0 || firstInit;
+    if (artifact.kind !== ArtifactKind.Fragment && hasChanged) {
+      const newVariables = {
+        ...ctx.stuff.inputs?.marshaled,
+        ...marshalInputs({
+          artifact,
+          input: changed,
+          config: source.config
+        })
+      };
+      ctx.stuff.inputs = {
+        init: true,
+        marshaled: newVariables,
+        changed: true
+      };
+      ctx.variables = val;
+    }
+    ctx.stuff = {
+      ...ctx.stuff,
+      inputs: {
+        ...ctx.stuff.inputs,
+        changed: !deepEquals(ctx.stuff.inputs.marshaled, this.#lastVariables)
+      }
+    };
+    return ctx;
+  }
+  apply(values, newVariables) {
+    if (newVariables) {
+      values = this.applyVariables(this.#context, values);
+    }
+    const wrapper = new ClientPluginContextWrapper({
+      ...values,
+      lastVariables: this.#lastVariables
+    });
+    return wrapper;
+  }
+}
+function marshalVariables(ctx) {
+  return ctx.stuff.inputs?.marshaled ?? {};
+}
+function variablesChanged(ctx) {
+  return ctx.stuff.inputs?.changed;
+}
+export {
+  DocumentStore
+};

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

@@ -0,0 +1,25 @@
+/// <reference path="../../../../../houdini.d.ts" />
+import type { DocumentArtifact, GraphQLObject } from '../lib/types';
+import type { ClientPlugin } from './documentStore';
+import { DocumentStore } from './documentStore';
+import { type FetchParamFn, type ThrowOnErrorParams } from './plugins';
+export { DocumentStore, type ClientPlugin } from './documentStore';
+export { fetchPlugin, mutationPlugin, queryPlugin, subscriptionPlugin } from './plugins';
+type ConstructorArgs = {
+    url: string;
+    fetchParams?: FetchParamFn;
+    plugins?: ClientPlugin[];
+    pipeline?: ClientPlugin[];
+    throwOnError?: ThrowOnErrorParams;
+};
+export declare class HoudiniClient {
+    #private;
+    url: string;
+    constructor({ url, fetchParams, plugins, pipeline, throwOnError }: ConstructorArgs);
+    observe<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, cache, initialValue, fetching, }: {
+        artifact: DocumentArtifact;
+        cache?: boolean;
+        initialValue?: _Data | null;
+        fetching?: boolean;
+    }): DocumentStore<_Data, _Input>;
+}