houdini 0.17.4 → 0.17.6

package/build/runtime-esm/lib/network.d.ts

@@ -5,6 +5,7 @@ export declare class HoudiniClient {
     private fetchFn;
     socket: SubscriptionHandler | null | undefined;
     constructor(networkFn: RequestHandler<any>, subscriptionHandler?: SubscriptionHandler | null);
+    handleMultipart(params: FetchParams, args: Parameters<FetchContext['fetch']>): Parameters<FetchContext['fetch']> | undefined;
     sendRequest<_Data>(ctx: FetchContext, params: FetchParams): Promise<RequestPayloadMagic<_Data>>;
 }
 export declare class Environment extends HoudiniClient {
@@ -53,11 +54,12 @@ export declare type RequestHandlerArgs = FetchContext & FetchParams & {
     session?: App.Session;
 };
 export declare type RequestHandler<_Data> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
-export declare function executeQuery<_Data extends GraphQLObject, _Input extends {}>({ client, artifact, variables, session, cached, fetch, metadata, }: {
+export declare function executeQuery<_Data extends GraphQLObject, _Input extends {}>({ client, artifact, variables, session, setFetching, cached, fetch, metadata, }: {
     client: HoudiniClient;
     artifact: QueryArtifact | MutationArtifact;
     variables: _Input;
     session: any;
+    setFetching: (fetching: boolean) => void;
     cached: boolean;
     config: ConfigFile;
     fetch?: typeof globalThis.fetch;
@@ -66,11 +68,12 @@ export declare function executeQuery<_Data extends GraphQLObject, _Input extends
     result: RequestPayload;
     partial: boolean;
 }>;
-export declare function fetchQuery<_Data extends GraphQLObject, _Input extends {}>({ client, artifact, variables, cached, policy, context, }: {
+export declare function fetchQuery<_Data extends GraphQLObject, _Input extends {}>({ client, context, artifact, variables, setFetching, cached, policy, }: {
     client: HoudiniClient;
     context: FetchContext;
     artifact: QueryArtifact | MutationArtifact;
     variables: _Input;
+    setFetching: (fetching: boolean) => void;
     cached?: boolean;
     policy?: CachePolicy;
 }): Promise<FetchQueryResult<_Data>>;

package/build/runtime-esm/lib/network.js

@@ -1,5 +1,6 @@
 import cache from "../cache";
 import * as log from "./log";
+import { extractFiles } from "./networkUtils";
 import {
   CachePolicy,
   DataSource
@@ -11,11 +12,42 @@ class HoudiniClient {
     this.fetchFn = networkFn;
     this.socket = subscriptionHandler;
   }
+  handleMultipart(params, args) {
+    const { clone, files } = extractFiles({
+      query: params.text,
+      variables: params.variables
+    });
+    if (files.size) {
+      const [url, 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 [url, { ...req, headers, body: form }];
+    }
+  }
   async sendRequest(ctx, params) {
     let url = "";
     const result = await this.fetchFn({
       fetch: async (...args) => {
-        const response = await ctx.fetch(...args);
+        const newArgs = this.handleMultipart(params, args);
+        const response = await ctx.fetch(...newArgs || args);
         if (response.url) {
           url = response.url;
         }
@@ -50,6 +82,7 @@ async function executeQuery({
   artifact,
   variables,
   session,
+  setFetching,
   cached,
   fetch,
   metadata
@@ -62,6 +95,7 @@ async function executeQuery({
       session
     },
     artifact,
+    setFetching,
     variables,
     cached
   });
@@ -75,11 +109,12 @@ async function executeQuery({
 }
 async function fetchQuery({
   client,
+  context,
   artifact,
   variables,
+  setFetching,
   cached = true,
-  policy,
-  context
+  policy
 }) {
   if (!client) {
     throw new Error("could not find houdini environment");
@@ -115,6 +150,7 @@ async function fetchQuery({
   setTimeout(() => {
     cache._internal_unstable.collectGarbage();
   }, 0);
+  setFetching(true);
   const result = await client.sendRequest(context, {
     text: artifact.raw,
     hash: artifact.hash,

package/build/runtime-esm/lib/networkUtils.d.ts

@@ -0,0 +1,8 @@
+export declare function isExtractableFile(value: any): value is ExtractableFile;
+declare 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/lib/networkUtils.js

@@ -0,0 +1,60 @@
+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,
+  isExtractableFile
+};