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

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

@@ -0,0 +1,58 @@
+import { DocumentStore } from "./documentStore";
+import {
+  fetchParamsPlugin,
+  fetchPlugin,
+  mutationPlugin,
+  queryPlugin,
+  throwOnErrorPlugin
+} from "./plugins";
+import pluginsFromPlugins from "./plugins/injectedPlugins";
+import { DocumentStore as DocumentStore2 } from "./documentStore";
+import { fetchPlugin as fetchPlugin2, mutationPlugin as mutationPlugin2, queryPlugin as queryPlugin2, subscriptionPlugin } 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 = [].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: this.#plugins,
+      cache,
+      initialValue,
+      fetching
+    });
+  }
+}
+export {
+  DocumentStore2 as DocumentStore,
+  HoudiniClient,
+  fetchPlugin2 as fetchPlugin,
+  mutationPlugin2 as mutationPlugin,
+  queryPlugin2 as queryPlugin,
+  subscriptionPlugin
+};

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 cachePolicyPlugin: ({ 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,69 @@
+import cache from "../../cache";
+import { ArtifactKind, CachePolicy, DataSource } from "../../lib/types";
+const cachePolicyPlugin = ({
+  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
+            });
+          }
+          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
+            });
+          }
+          if (useCache && !value.partial) {
+            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 {
+  cachePolicyPlugin
+};

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 fetchPlugin: (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 {};

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

@@ -0,0 +1,151 @@
+import { DataSource } from "../../lib/types";
+const fetchPlugin = (target) => {
+  return () => {
+    return {
+      async network(ctx, { client, resolve, marshalVariables }) {
+        const fetch = ctx.fetch ?? globalThis.fetch;
+        const fetchParams = {
+          text: ctx.text,
+          hash: ctx.hash,
+          variables: marshalVariables(ctx)
+        };
+        let fetchFn = defaultFetch(client.url, ctx.fetchParams);
+        if (target) {
+          if (typeof target === "string") {
+            fetchFn = defaultFetch(target, ctx.fetchParams);
+          } else {
+            fetchFn = target;
+          }
+        }
+        const result = await fetchFn({
+          fetch: (url, args) => {
+            const newArgs = handleMultipart(fetchParams, args) ?? args;
+            return fetch(url, newArgs);
+          },
+          metadata: ctx.metadata,
+          session: ctx.session || {},
+          ...fetchParams
+        });
+        resolve(ctx, {
+          fetching: false,
+          variables: ctx.variables ?? null,
+          data: result.data,
+          errors: !result.errors || result.errors.length === 0 ? null : result.errors,
+          partial: false,
+          source: DataSource.Network
+        });
+      }
+    };
+  };
+};
+const defaultFetch = (url, params) => {
+  if (!url) {
+    throw new Error(
+      "Could not find configured client url. Please specify one in your houdini.config.js file."
+    );
+  }
+  return async ({ fetch, text, variables }) => {
+    const result = await fetch(url, {
+      method: "POST",
+      body: JSON.stringify({ query: text, variables }),
+      ...params,
+      headers: {
+        Accept: "application/graphql+json, application/json",
+        "Content-Type": "application/json",
+        ...params?.headers
+      }
+    });
+    return await result.json();
+  };
+};
+function handleMultipart(params, args) {
+  const { clone, files } = extractFiles({
+    query: params.text,
+    variables: params.variables
+  });
+  if (files.size) {
+    const req = args;
+    let headers = {};
+    if (req?.headers) {
+      const filtered = Object.entries(req?.headers).filter(([key, value]) => {
+        return !(key.toLowerCase() == "content-type" && value.toLowerCase() == "application/json");
+      });
+      headers = Object.fromEntries(filtered);
+    }
+    const form = new FormData();
+    const operationJSON = JSON.stringify(clone);
+    form.set("operations", operationJSON);
+    const map = {};
+    let i = 0;
+    files.forEach((paths) => {
+      map[++i] = paths;
+    });
+    form.set("map", JSON.stringify(map));
+    i = 0;
+    files.forEach((paths, file) => {
+      form.set(`${++i}`, file, file.name);
+    });
+    return { ...req, headers, body: form };
+  }
+}
+function isExtractableFile(value) {
+  return typeof File !== "undefined" && value instanceof File || typeof Blob !== "undefined" && value instanceof Blob;
+}
+function extractFiles(value) {
+  if (!arguments.length)
+    throw new TypeError("Argument 1 `value` is required.");
+  const clones = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  function recurse(value2, path, recursed) {
+    if (isExtractableFile(value2)) {
+      const filePaths = files.get(value2);
+      filePaths ? filePaths.push(path) : files.set(value2, [path]);
+      return null;
+    }
+    const valueIsList = Array.isArray(value2) || typeof FileList !== "undefined" && value2 instanceof FileList;
+    const valueIsPlainObject = isPlainObject(value2);
+    if (valueIsList || valueIsPlainObject) {
+      let clone = clones.get(value2);
+      const uncloned = !clone;
+      if (uncloned) {
+        clone = valueIsList ? [] : value2 instanceof Object ? {} : /* @__PURE__ */ Object.create(null);
+        clones.set(value2, clone);
+      }
+      if (!recursed.has(value2)) {
+        const pathPrefix = path ? `${path}.` : "";
+        const recursedDeeper = new Set(recursed).add(value2);
+        if (valueIsList) {
+          let index = 0;
+          for (const item of value2) {
+            const itemClone = recurse(item, pathPrefix + index++, recursedDeeper);
+            if (uncloned)
+              clone.push(itemClone);
+          }
+        } else
+          for (const key in value2) {
+            const propertyClone = recurse(value2[key], pathPrefix + key, recursedDeeper);
+            if (uncloned)
+              clone[key] = propertyClone;
+          }
+      }
+      return clone;
+    }
+    return value2;
+  }
+  return {
+    clone: recurse(value, "", /* @__PURE__ */ new Set()),
+    files
+  };
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+export {
+  extractFiles,
+  fetchPlugin,
+  isExtractableFile
+};

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

@@ -0,0 +1,9 @@
+import type { DocumentArtifact } from '../../lib/types';
+import type { ClientPlugin, ClientPluginContext } from '../documentStore';
+export type FetchParamFn = (ctx: FetchParamsInput) => Required<ClientPluginContext>['fetchParams'];
+export declare const fetchParamsPlugin: (fn?: FetchParamFn) => ClientPlugin;
+export type FetchParamsInput = Pick<ClientPluginContext, 'config' | 'policy' | 'variables' | 'metadata' | 'session' | 'stuff'> & {
+    text: string;
+    hash: string;
+    artifact: DocumentArtifact;
+};

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

@@ -0,0 +1,16 @@
+const fetchParamsPlugin = (fn = () => ({})) => () => ({
+  beforeNetwork(ctx, { next, marshalVariables }) {
+    next({
+      ...ctx,
+      fetchParams: fn({
+        ...ctx,
+        variables: marshalVariables(ctx),
+        text: ctx.artifact.raw,
+        hash: ctx.artifact.hash
+      })
+    });
+  }
+});
+export {
+  fetchParamsPlugin
+};

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

@@ -0,0 +1,7 @@
+export * from './fetch';
+export * from './cache';
+export * from './query';
+export * from './mutation';
+export * from './subscription';
+export * from './throwOnError';
+export * from './fetchParams';

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

@@ -0,0 +1,7 @@
+export * from "./fetch";
+export * from "./cache";
+export * from "./query";
+export * from "./mutation";
+export * from "./subscription";
+export * from "./throwOnError";
+export * from "./fetchParams";

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

@@ -0,0 +1,3 @@
+import type { ClientPlugin } from '../documentStore';
+declare const plugins: ClientPlugin[];
+export default plugins;

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

@@ -0,0 +1,5 @@
+const plugins = [];
+var injectedPlugins_default = plugins;
+export {
+  injectedPlugins_default as default
+};

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

@@ -0,0 +1 @@
+export declare const mutationPlugin: import("..").ClientPlugin;

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

@@ -0,0 +1,56 @@
+import cache from "../../cache";
+import { marshalSelection } from "../../lib/scalars";
+import { ArtifactKind } from "../../lib/types";
+import { documentPlugin } from "../utils";
+const mutationPlugin = documentPlugin(ArtifactKind.Mutation, () => {
+  return {
+    async start(ctx, { next, marshalVariables }) {
+      const layer = cache._internal_unstable.storage.createLayer(true);
+      const optimisticResponse = ctx.stuff.optimisticResponse;
+      let toNotify = [];
+      if (optimisticResponse) {
+        toNotify = cache.write({
+          selection: ctx.artifact.selection,
+          data: await marshalSelection({
+            selection: ctx.artifact.selection,
+            data: optimisticResponse
+          }),
+          variables: marshalVariables(ctx),
+          layer: layer.id
+        });
+      }
+      ctx.cacheParams = {
+        ...ctx.cacheParams,
+        layer,
+        notifySubscribers: toNotify,
+        forceNotify: true
+      };
+      next(ctx);
+    },
+    afterNetwork(ctx, { resolve }) {
+      ctx.cacheParams?.layer?.clear();
+      resolve(ctx);
+    },
+    end(ctx, { resolve, value }) {
+      const hasErrors = value.errors && value.errors.length > 0;
+      if (hasErrors) {
+        ctx.cacheParams?.layer?.clear();
+      }
+      if (ctx.cacheParams?.layer) {
+        cache._internal_unstable.storage.resolveLayer(ctx.cacheParams.layer.id);
+      }
+      resolve(ctx);
+    },
+    catch(ctx, { error }) {
+      if (ctx.cacheParams?.layer) {
+        const { layer } = ctx.cacheParams;
+        layer.clear();
+        cache._internal_unstable.storage.resolveLayer(layer.id);
+      }
+      throw error;
+    }
+  };
+});
+export {
+  mutationPlugin
+};

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

@@ -0,0 +1,2 @@
+import type { ClientPlugin } from '../documentStore';
+export declare const queryPlugin: ClientPlugin;

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

@@ -0,0 +1,53 @@
+import cache from "../../cache";
+import { ArtifactKind, DataSource } from "../../lib/types";
+import { documentPlugin } from "../utils";
+const queryPlugin = documentPlugin(ArtifactKind.Query, function() {
+  let subscriptionSpec = null;
+  let lastVariables = null;
+  let artifactName = "";
+  return {
+    start(ctx, { next }) {
+      ctx.variables = {
+        ...lastVariables,
+        ...ctx.variables
+      };
+      next(ctx);
+    },
+    end(ctx, { resolve, marshalVariables, variablesChanged }) {
+      if (variablesChanged(ctx)) {
+        artifactName = ctx.artifact.name;
+        if (subscriptionSpec) {
+          cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
+        }
+        lastVariables = { ...marshalVariables(ctx) };
+        subscriptionSpec = {
+          rootType: ctx.artifact.rootType,
+          selection: ctx.artifact.selection,
+          variables: () => lastVariables,
+          set: (newValue) => {
+            console.log("setting from cache update");
+            resolve(ctx, {
+              data: newValue,
+              errors: null,
+              fetching: false,
+              partial: false,
+              source: DataSource.Cache,
+              variables: ctx.variables ?? null
+            });
+          }
+        };
+        cache.subscribe(subscriptionSpec, lastVariables ?? {});
+      }
+      resolve(ctx);
+    },
+    cleanup() {
+      if (subscriptionSpec) {
+        cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() ?? {});
+        lastVariables = null;
+      }
+    }
+  };
+});
+export {
+  queryPlugin
+};

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

@@ -0,0 +1,18 @@
+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) => {
+    subscribe: (payload: {
+        query: string;
+        variables?: {};
+    }, handlers: {
+        next: (payload: {
+            data?: GraphQLObject;
+            errors?: readonly {
+                message: string;
+            }[];
+        }) => void;
+        error: (data: {}) => void;
+        complete: () => void;
+    }) => () => void;
+};

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

@@ -0,0 +1,74 @@
+import { deepEquals } from "../../lib/deepEquals";
+import { ArtifactKind, DataSource } from "../../lib/types";
+import { documentPlugin } from "../utils";
+function subscriptionPlugin(factory) {
+  return documentPlugin(ArtifactKind.Subscription, () => {
+    let clearSubscription = null;
+    let socketClient = null;
+    let check = null;
+    return {
+      start(ctx, { resolve, next, initialValue }) {
+        if (typeof globalThis.window === "undefined") {
+          resolve(ctx, initialValue);
+          return;
+        }
+        next(ctx);
+      },
+      network(ctx, { resolve, initialValue, variablesChanged, marshalVariables }) {
+        const checkValue = {
+          fetchParams: ctx.fetchParams ?? {},
+          session: ctx.session ?? {},
+          metadata: ctx.metadata ?? {}
+        };
+        const changed = variablesChanged(ctx);
+        const sessionChange = !deepEquals(check, checkValue);
+        if (!changed && !sessionChange) {
+          resolve(ctx, initialValue);
+          return;
+        }
+        check = checkValue;
+        clearSubscription?.();
+        if (!socketClient || sessionChange) {
+          socketClient = factory(ctx);
+        }
+        clearSubscription = socketClient.subscribe(
+          {
+            query: ctx.artifact.raw,
+            variables: marshalVariables(ctx)
+          },
+          {
+            next: ({ data, errors }) => {
+              resolve(ctx, {
+                data: data ?? null,
+                errors: [...errors ?? []],
+                fetching: false,
+                partial: true,
+                source: DataSource.Network,
+                variables: ctx.variables ?? null
+              });
+            },
+            error(data) {
+              clearSubscription?.();
+              resolve(ctx, {
+                partial: true,
+                source: DataSource.Network,
+                data: null,
+                errors: [data],
+                fetching: false,
+                variables: ctx.variables ?? null
+              });
+            },
+            complete() {
+            }
+          }
+        );
+      },
+      cleanup() {
+        clearSubscription?.();
+      }
+    };
+  });
+}
+export {
+  subscriptionPlugin
+};

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

@@ -0,0 +1,7 @@
+import type { QueryResult } from '../../lib';
+import type { ClientPlugin } from '../documentStore';
+export type ThrowOnErrorParams = {
+    operations: ('all' | 'query' | 'mutation' | 'subscription')[];
+    error?: (errors: NonNullable<QueryResult<any, any>['errors']>) => unknown;
+};
+export declare const throwOnErrorPlugin: ({ operations, error }: ThrowOnErrorParams) => ClientPlugin;

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

@@ -0,0 +1,23 @@
+import { ArtifactKind } from "../../lib";
+const throwOnErrorPlugin = ({ operations, error }) => () => {
+  const all = operations.includes("all");
+  const throwOnKind = (kind) => all || {
+    [ArtifactKind.Query]: operations.includes("query"),
+    [ArtifactKind.Mutation]: operations.includes("mutation"),
+    [ArtifactKind.Fragment]: false,
+    [ArtifactKind.Subscription]: operations.includes("subscription")
+  }[kind];
+  return {
+    async end(ctx, { value, resolve }) {
+      if (value.errors && value.errors.length > 0 && throwOnKind(ctx.artifact.kind)) {
+        const result = await (error ?? defaultErrorFn)(value.errors);
+        throw result;
+      }
+      resolve(ctx);
+    }
+  };
+};
+const defaultErrorFn = async (errors) => new Error(errors.map((error) => error.message).join(". ") + ".");
+export {
+  throwOnErrorPlugin
+};

package/build/runtime-esm/client/utils/documentPlugins.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactKind } from '../../lib/types';
+import type { ClientPlugin } from '../documentStore';
+export declare const documentPlugin: (kind: ArtifactKind, source: ClientPlugin) => ClientPlugin;

package/build/runtime-esm/client/utils/documentPlugins.js

@@ -0,0 +1,32 @@
+const documentPlugin = (kind, source) => {
+  return () => {
+    const sourceHandlers = source();
+    const enterWrapper = (handler) => {
+      return !handler ? void 0 : (ctx, handlers) => {
+        if (ctx.artifact.kind !== kind) {
+          return handlers.next(ctx);
+        }
+        return handler(ctx, handlers);
+      };
+    };
+    const exitWrapper = (handler) => {
+      return !handler ? void 0 : (ctx, handlers) => {
+        if (ctx.artifact.kind !== kind) {
+          return handlers.resolve(ctx);
+        }
+        return handler(ctx, handlers);
+      };
+    };
+    return {
+      start: enterWrapper(sourceHandlers.start),
+      network: enterWrapper(sourceHandlers.network),
+      afterNetwork: exitWrapper(sourceHandlers.afterNetwork),
+      end: exitWrapper(sourceHandlers.end),
+      catch: sourceHandlers.catch ? (ctx, handlers) => sourceHandlers.catch(ctx, handlers) : void 0,
+      cleanup: (...args) => sourceHandlers.cleanup?.(...args)
+    };
+  };
+};
+export {
+  documentPlugin
+};

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

@@ -0,0 +1 @@
+export * from './documentPlugins';

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

@@ -0,0 +1 @@
+export * from "./documentPlugins";

package/build/runtime-esm/generated.d.ts

@@ -1,4 +1,5 @@
 export type CacheTypeDef = {
     types: {};
     lists: {};
+    queries: [];
 };