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

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

@@ -0,0 +1,337 @@
+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 { cachePolicy } 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,
+      stale: 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 ?? [
+      cachePolicy({
+        enabled: cache,
+        setFetching: (fetching2) => this.update((state) => ({ ...state, fetching: fetching2 }))
+      })(),
+      ...plugins ?? []
+    ];
+  }
+  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,27 @@
+/// <reference path="../../../../../houdini.d.ts" />
+import type { DocumentArtifact, GraphQLObject, NestedList } from '../lib/types';
+import type { ClientPlugin, ClientHooks } from './documentStore';
+import { DocumentStore } from './documentStore';
+import { type FetchParamFn, type ThrowOnErrorParams } from './plugins';
+export { DocumentStore, type ClientPlugin } from './documentStore';
+export { fetch, mutation, query, subscription } from './plugins';
+type ConstructorArgs = {
+    url: string;
+    fetchParams?: FetchParamFn;
+    plugins?: NestedList<ClientPlugin>;
+    pipeline?: NestedList<ClientPlugin>;
+    throwOnError?: ThrowOnErrorParams;
+};
+export type ObserveParams<_Data extends GraphQLObject, _Artifact extends DocumentArtifact = DocumentArtifact> = {
+    artifact: _Artifact;
+    cache?: boolean;
+    initialValue?: _Data | null;
+    fetching?: boolean;
+};
+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, }: ObserveParams<_Data>): DocumentStore<_Data, _Input>;
+}
+export declare function createPluginHooks(plugins: ClientPlugin[]): ClientHooks[];

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

@@ -0,0 +1,83 @@
+import { flatten } from "../lib/flatten";
+import { DocumentStore } from "./documentStore";
+import {
+  fetchParams as fetchParamsPlugin,
+  fetch as fetchPlugin,
+  mutation as mutationPlugin,
+  query as queryPlugin,
+  throwOnError as throwOnErrorPlugin
+} from "./plugins";
+import pluginsFromPlugins from "./plugins/injectedPlugins";
+import { DocumentStore as DocumentStore2 } from "./documentStore";
+import { fetch, mutation, query, subscription } from "./plugins";
+class HoudiniClient {
+  url;
+  #plugins;
+  constructor({ url, fetchParams, plugins, pipeline, throwOnError }) {
+    if (plugins && pipeline) {
+      throw new Error(
+        "A client cannot be given a pipeline and a list of plugins at the same time."
+      );
+    }
+    this.#plugins = flatten(
+      [].concat(
+        throwOnError ? [throwOnErrorPlugin(throwOnError)] : [],
+        fetchParamsPlugin(fetchParams),
+        pipeline ?? [
+          queryPlugin,
+          mutationPlugin
+        ].concat(
+          plugins ?? [],
+          pluginsFromPlugins,
+          fetchPlugin()
+        )
+      )
+    );
+    this.url = url;
+  }
+  observe({
+    artifact,
+    cache = true,
+    initialValue,
+    fetching = false
+  }) {
+    return new DocumentStore({
+      client: this,
+      artifact,
+      plugins: createPluginHooks(this.#plugins),
+      cache,
+      initialValue,
+      fetching
+    });
+  }
+}
+function createPluginHooks(plugins) {
+  return plugins.reduce((hooks, plugin) => {
+    const result = plugin();
+    if (!result) {
+      return hooks;
+    }
+    if (!Array.isArray(result)) {
+      return hooks.concat(result);
+    }
+    for (const value of result) {
+      if (!value) {
+        continue;
+      }
+      if (typeof value === "function") {
+        return hooks.concat(createPluginHooks([value]));
+      }
+      hooks.push(value);
+    }
+    return hooks;
+  }, []);
+}
+export {
+  DocumentStore2 as DocumentStore,
+  HoudiniClient,
+  createPluginHooks,
+  fetch,
+  mutation,
+  query,
+  subscription
+};

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

@@ -0,0 +1,8 @@
+import cache from '../../cache';
+import type { Cache } from '../../cache/cache';
+import type { ClientPlugin } from '../documentStore';
+export declare const cachePolicy: ({ enabled, setFetching, cache: localCache, }: {
+    enabled: boolean;
+    setFetching: (val: boolean) => void;
+    cache?: Cache | undefined;
+}) => ClientPlugin;

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

@@ -0,0 +1,71 @@
+import cache from "../../cache";
+import { ArtifactKind, CachePolicy, DataSource } from "../../lib/types";
+const cachePolicy = ({
+  enabled,
+  setFetching,
+  cache: localCache = cache
+}) => () => {
+  return {
+    network(ctx, { next, resolve, marshalVariables }) {
+      const { policy, artifact } = ctx;
+      let useCache = false;
+      if (enabled && artifact.kind === ArtifactKind.Query && !ctx.cacheParams?.disableRead) {
+        if (policy !== CachePolicy.NetworkOnly) {
+          const value = localCache.read({
+            selection: artifact.selection,
+            variables: marshalVariables(ctx)
+          });
+          const allowed = !value.partial || artifact.kind === ArtifactKind.Query && artifact.partial;
+          if (policy === CachePolicy.CacheOnly) {
+            return resolve(ctx, {
+              fetching: false,
+              variables: ctx.variables ?? null,
+              data: value.data,
+              errors: null,
+              source: DataSource.Cache,
+              partial: value.partial,
+              stale: value.stale
+            });
+          }
+          useCache = !!(value.data !== null && allowed);
+          if (useCache) {
+            resolve(ctx, {
+              fetching: false,
+              variables: ctx.variables ?? null,
+              data: value.data,
+              errors: null,
+              source: DataSource.Cache,
+              partial: value.partial,
+              stale: value.stale
+            });
+          }
+          if (useCache && !value.partial && !value.stale) {
+            return;
+          }
+        }
+      }
+      if (enabled) {
+        setTimeout(() => {
+          localCache._internal_unstable.collectGarbage();
+        }, 0);
+      }
+      setFetching(!useCache);
+      return next(ctx);
+    },
+    afterNetwork(ctx, { resolve, value, marshalVariables }) {
+      if (value.source !== DataSource.Cache && enabled && value.data && !ctx.cacheParams?.disableWrite) {
+        localCache.write({
+          ...ctx.cacheParams,
+          layer: ctx.cacheParams?.layer?.id,
+          selection: ctx.artifact.selection,
+          data: value.data,
+          variables: marshalVariables(ctx)
+        });
+      }
+      resolve(ctx, value);
+    }
+  };
+};
+export {
+  cachePolicy
+};

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

@@ -0,0 +1,37 @@
+import type { RequestPayload } from '../../lib/types';
+import type { ClientPlugin } from '../documentStore';
+export declare const fetch: (target?: RequestHandler | string) => ClientPlugin;
+export type FetchContext = {
+    fetch: typeof globalThis.fetch;
+    metadata?: App.Metadata | null;
+    session: App.Session | null;
+};
+/**
+ * ## Tip 👇
+ *
+ * To define types for your metadata, create a file `src/app.d.ts` containing the followingI:
+ *
+ * ```ts
+ * declare namespace App { *
+ * 	interface Metadata {}
+ * }
+ * ```
+ *
+ */
+export type RequestHandlerArgs = FetchContext & FetchParams;
+export type RequestHandler<_Data = any> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
+export type FetchParams = {
+    text: string;
+    hash: string;
+    variables: {
+        [key: string]: any;
+    };
+};
+export declare function isExtractableFile(value: any): value is ExtractableFile;
+type ExtractableFile = File | Blob;
+/** @typedef {import("./isExtractableFile.mjs").default} isExtractableFile */
+export declare function extractFiles(value: any): {
+    clone: any;
+    files: Map<any, any>;
+};
+export {};