nuxt-graphql-middleware 4.1.1 → 4.3.0

package/dist/module.mjs

@@ -1,7 +1,7 @@
 import { fileURLToPath } from 'url';
 import { dirname, resolve, relative } from 'pathe';
 import { defu } from 'defu';
-import { useLogger, resolveAlias, resolveFiles, defineNuxtModule, createResolver, addImports, addTemplate, addServerHandler, addPlugin, updateTemplates } from '@nuxt/kit';
+import { useLogger, resolveAlias, resolveFiles, defineNuxtModule, createResolver, addImports, addServerImports, addTemplate, addServerHandler, addPlugin, updateTemplates } from '@nuxt/kit';
 import inquirer from 'inquirer';
 import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
 import { existsSync } from 'fs';
@@ -21,7 +21,7 @@ import { pascalCase } from 'change-case-all';
 import colors from 'picocolors';
 
 const name = "nuxt-graphql-middleware";
-const version = "4.1.1";
+const version = "4.3.0";
 
 const DEVTOOLS_UI_ROUTE = "/__nuxt-graphql-middleware";
 const DEVTOOLS_UI_LOCAL_PORT = 3300;
@@ -239,10 +239,10 @@ const plugin$1 = (_schema, documents, config) => {
 import type { GraphqlResponse } from '#graphql-middleware-server-options-build'
 import type {
   ${imports.join(",\n  ")}
-} from './graphql-operations'
+} from './../graphql-operations'
 
 
-declare module '#build/nuxt-graphql-middleware' {
+declare module '#nuxt-graphql-middleware/generated-types' {
   export type GraphqlMiddlewareResponseUnion = ${resultTypes.join(" | ")}
 ${code}
 }
@@ -400,7 +400,7 @@ const defaultOptions = {
     }
   },
   downloadSchema: true,
-  schemaPath: "./schema.graphql",
+  schemaPath: "~~/schema.graphql",
   serverApiPrefix: "/api/graphql_middleware",
   graphqlEndpoint: "",
   debug: false,
@@ -423,8 +423,8 @@ function validateOptions(options) {
     throw new Error("Missing graphqlEndpoint.");
   }
 }
-async function getSchemaPath(options, resolver, writeToDisk = false) {
-  const dest = resolver(options.schemaPath);
+async function getSchemaPath(schemaPath, options, resolver, writeToDisk = false) {
+  const dest = resolver(schemaPath);
   if (!options.downloadSchema) {
     const fileExists2 = await promises.access(dest).then(() => true).catch(() => false);
     if (!fileExists2) {
@@ -505,6 +505,9 @@ async function buildDocuments(providedDocuments = [], autoImportPatterns, resolv
       return documents2;
     }
     return documents2.map((v) => {
+      if (!v.content.trim()) {
+        return null;
+      }
       try {
         return {
           content: inlineFragments(v.content, resolveAlias),
@@ -518,6 +521,8 @@ async function buildDocuments(providedDocuments = [], autoImportPatterns, resolv
       }
       return null;
     }).filter(falsy);
+  }).then((docs) => {
+    return docs.filter((v) => v.content.trim());
   });
   if (!autoInlineFragments) {
     return documents;
@@ -536,23 +541,23 @@ async function buildDocuments(providedDocuments = [], autoImportPatterns, resolv
   });
   return documents;
 }
-function parseDocument(document, srcDir) {
-  let name = document.filename ? document.filename.replace(srcDir, "") : "";
+function parseDocument(document, rootDir) {
+  let name = document.filename ? document.filename.replace(rootDir, "") : "";
   if (name.charAt(0) === "/") {
     name = name.slice(1);
   }
   const source = new Source(document.content, name);
   return parse(source);
 }
-function validateDocuments(schema, documents, srcDir) {
+function validateDocuments(schema, documents, rootDir) {
   const validated = [];
   for (let i = 0; i < documents.length; i++) {
     const document = { ...documents[i] };
     if (document.filename) {
-      document.relativePath = document.filename.replace(srcDir + "/", "");
+      document.relativePath = document.filename.replace(rootDir + "/", "");
     }
     try {
-      const node = parseDocument(document, srcDir);
+      const node = parseDocument(document, rootDir);
       document.content = print(node);
       document.errors = validateGraphQlDocuments(schema, [
         node
@@ -626,7 +631,7 @@ function cleanGraphqlDocument(graphqlContent, operationName) {
     ]
   };
 }
-async function generate(options, schemaPath, resolver, srcDir, logEverything = false) {
+async function generate(options, schemaPath, resolver, rootDir, logEverything = false) {
   const schemaContent = await promises.readFile(schemaPath).then((v) => v.toString());
   const schema = await loadSchema(schemaContent, { loaders: [] });
   const documents = await buildDocuments(
@@ -635,12 +640,15 @@ async function generate(options, schemaPath, resolver, srcDir, logEverything = f
     resolver,
     !!options.autoInlineFragments
   );
-  const validated = validateDocuments(schema, documents, srcDir);
+  const validated = validateDocuments(schema, documents, rootDir);
   const extracted = validated.filter(
     (v) => !v.operation
   );
   for (let i = 0; i < validated.length; i++) {
     const v = validated[i];
+    if (!v) {
+      continue;
+    }
     if (v.isValid) {
       try {
         const node = parse(v.content);
@@ -704,7 +712,7 @@ async function generate(options, schemaPath, resolver, srcDir, logEverything = f
     })
   };
 }
-const fileExists = (path, extensions = ["js", "ts"]) => {
+const fileExists = (path, extensions = ["js", "ts", "mjs"]) => {
   if (!path) {
     return null;
   } else if (existsSync$1(path)) {
@@ -733,22 +741,45 @@ const module = defineNuxtModule({
     configKey: "graphqlMiddleware",
     version,
     compatibility: {
-      nuxt: ">=3.1.0"
+      nuxt: ">=3.13.0"
     }
   },
   defaults: defaultOptions,
   async setup(passedOptions, nuxt) {
     const options = defu({}, passedOptions, defaultOptions);
+    const isModuleBuild = process.env.MODULE_BUILD === "true" && nuxt.options._prepare;
+    if (isModuleBuild) {
+      options.graphqlEndpoint = "http://localhost";
+      options.downloadSchema = false;
+      options.schemaPath = "~~/schema.graphql";
+      options.autoInlineFragments = true;
+      options.autoImportPatterns = [
+        "~~/playground/**/*.{gql,graphql}",
+        "!node_modules"
+      ];
+    }
     if (!passedOptions.autoImportPatterns) {
-      options.autoImportPatterns = ["**/*.{gql,graphql}", "!node_modules"];
+      options.autoImportPatterns = ["~~/**/*.{gql,graphql}", "!node_modules"];
+    }
+    options.autoImportPatterns = (options.autoImportPatterns || []).map(
+      (pattern) => {
+        return resolveAlias(pattern);
+      }
+    );
+    if (!nuxt.options._prepare) {
+      validateOptions(options);
     }
-    validateOptions(options);
+    const schemaPathReplaced = resolveAlias(options.schemaPath);
     const moduleResolver = createResolver(import.meta.url);
-    const srcDir = nuxt.options.srcDir;
-    const srcResolver = createResolver(srcDir).resolve;
+    const serverResolver = createResolver(nuxt.options.serverDir);
+    const srcResolver = createResolver(nuxt.options.srcDir);
+    const appResolver = createResolver(nuxt.options.dir.app);
+    const rootDir = nuxt.options.rootDir;
+    const rootResolver = createResolver(rootDir);
     const schemaPath = await getSchemaPath(
+      schemaPathReplaced,
       options,
-      srcResolver,
+      rootResolver.resolve,
       options.downloadSchema
     );
     const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
@@ -790,8 +821,8 @@ const module = defineNuxtModule({
         const { templates, hasErrors, documents } = await generate(
           options,
           schemaPath,
-          srcResolver,
-          srcDir,
+          rootResolver.resolve,
+          rootDir,
           isFirst
         );
         ctx.templates = templates;
@@ -831,7 +862,12 @@ const module = defineNuxtModule({
         });
         prompt.then(async ({ accept }) => {
           if (accept) {
-            await getSchemaPath(options, srcResolver, true);
+            await getSchemaPath(
+              schemaPathReplaced,
+              options,
+              rootResolver.resolve,
+              true
+            );
             await generateHandler();
           }
         });
@@ -849,37 +885,30 @@ const module = defineNuxtModule({
       graphqlEndpoint: options.graphqlEndpoint || ""
     };
     if (options.includeComposables) {
-      addImports({
-        from: moduleResolver.resolve("./runtime/composables/useGraphqlQuery"),
-        name: "useGraphqlQuery"
-      });
-      addImports({
-        from: moduleResolver.resolve(
-          "./runtime/composables/useGraphqlMutation"
-        ),
-        name: "useGraphqlMutation"
-      });
-      addImports({
-        from: moduleResolver.resolve("./runtime/composables/useGraphqlState"),
-        name: "useGraphqlState"
-      });
-      addImports({
-        from: moduleResolver.resolve(
-          "./runtime/composables/useAsyncGraphqlQuery"
-        ),
-        name: "useAsyncGraphqlQuery"
-      });
-      nuxt.options.alias["#graphql-composable"] = moduleResolver.resolve(
-        "runtime/composables/server"
-      );
+      const nuxtComposables = [
+        "useGraphqlQuery",
+        "useGraphqlMutation",
+        "useGraphqlState",
+        "useAsyncGraphqlQuery"
+      ];
       if (options.enableFileUploads) {
+        nuxtComposables.push("useGraphqlUploadMutation");
+      }
+      nuxtComposables.forEach((name2) => {
         addImports({
-          from: moduleResolver.resolve(
-            "./runtime/composables/useGraphqlUploadMutation"
-          ),
-          name: "useGraphqlUploadMutation"
+          from: moduleResolver.resolve("./runtime/composables/" + name2),
+          name: name2
         });
-      }
+      });
+      const serverUtils = ["useGraphqlQuery", "useGraphqlMutation"].map(
+        (name2) => {
+          return {
+            from: moduleResolver.resolve("./runtime/server/utils/" + name2),
+            name: name2
+          };
+        }
+      );
+      addServerImports(serverUtils);
     }
     Object.values(GraphqlMiddlewareTemplate).forEach((filename) => {
       const result = addTemplate({
@@ -896,6 +925,8 @@ const module = defineNuxtModule({
         nuxt.options.alias["#graphql-documents"] = result.dst;
       } else if (result.dst.includes(GraphqlMiddlewareTemplate.OperationTypes)) {
         nuxt.options.alias["#graphql-operations"] = result.dst;
+      } else if (result.dst.includes(GraphqlMiddlewareTemplate.ComposableContext)) {
+        nuxt.options.alias["#nuxt-graphql-middleware/generated-types"] = result.dst;
       }
     });
     addTemplate({
@@ -906,7 +937,7 @@ const module = defineNuxtModule({
 import type {
   GraphqlMiddlewareQuery,
   GraphqlMiddlewareMutation,
-} from '#build/nuxt-graphql-middleware'
+} from '#nuxt-graphql-middleware/generated-types'
 
 declare module '#graphql-documents' {
   type Documents = {
@@ -919,36 +950,109 @@ declare module '#graphql-documents' {
 `;
       }
     });
-    const extensions = ["js", "mjs", "ts"];
-    const resolvedPath = "~/app/graphqlMiddleware.serverOptions".replace(/^(~~|@@)/, nuxt.options.rootDir).replace(/^(~|@)/, nuxt.options.srcDir);
-    const template = (() => {
-      const resolvedFilename = `graphqlMiddleware.serverOptions.ts`;
-      const maybeUserFile = fileExists(resolvedPath, extensions);
-      const moduleTypesPath = relative(
-        nuxt.options.buildDir,
-        moduleResolver.resolve("./types")
-      );
-      const serverOptionsLine = maybeUserFile ? `import serverOptions from './../app/graphqlMiddleware.serverOptions'` : `const serverOptions: GraphqlMiddlewareServerOptions = {}`;
-      return addTemplate({
-        filename: resolvedFilename,
-        write: true,
-        getContents: () => `
-import type { GraphqlMiddlewareServerOptions } from '${moduleTypesPath}'
+    const findServerOptions = () => {
+      const newPath = serverResolver.resolve("graphqlMiddleware.serverOptions");
+      const serverPath = fileExists(newPath);
+      if (serverPath) {
+        return serverPath;
+      }
+      const candidates = [
+        rootResolver.resolve("graphqlMiddleware.serverOptions"),
+        rootResolver.resolve("app/graphqlMiddleware.serverOptions"),
+        srcResolver.resolve("graphqlMiddleware.serverOptions")
+      ];
+      for (let i = 0; i < candidates.length; i++) {
+        const path = candidates[i];
+        const filePath = fileExists(path);
+        if (filePath) {
+          logger.warn(
+            `The graphqlMiddleware.serverOptions file should be placed in Nuxt's <serverDir> ("${nuxt.options.serverDir}/graphqlMiddleware.serverOptions.ts"). The new path will be enforced in the next major release.`
+          );
+          return filePath;
+        }
+      }
+      logger.info("No graphqlMiddleware.serverOptions file found.");
+    };
+    const resolvedPath = findServerOptions();
+    const moduleTypesPath = relative(
+      nuxt.options.buildDir,
+      moduleResolver.resolve("./types")
+    );
+    const resolvedPathRelative = resolvedPath ? relative(nuxt.options.buildDir, resolvedPath) : null;
+    const template = addTemplate({
+      filename: "graphqlMiddleware.serverOptions.mjs",
+      write: true,
+      getContents: () => {
+        const serverOptionsLine = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions = {}`;
+        return `
 ${serverOptionsLine}
+export { serverOptions }
+`;
+      }
+    });
+    addTemplate({
+      filename: "graphqlMiddleware.serverOptions.d.ts",
+      write: true,
+      getContents: () => {
+        const serverOptionsLineTypes = resolvedPathRelative ? `import serverOptions from '${resolvedPathRelative}'` : `const serverOptions: GraphqlMiddlewareServerOptions = {}`;
+        return `
+import type { GraphqlMiddlewareServerOptions } from '${moduleTypesPath}'
+${serverOptionsLineTypes}
 import type { GraphqlServerResponse } from '#graphql-middleware/types'
-import type { GraphqlMiddlewareResponseUnion } from '#build/nuxt-graphql-middleware'
+import type { GraphqlMiddlewareResponseUnion } from '#nuxt-graphql-middleware/generated-types'
 
 type GraphqlResponseAdditions =
-  typeof serverOptions extends GraphqlMiddlewareServerOptions<infer R> ? R : {}
+  typeof serverOptions extends GraphqlMiddlewareServerOptions<infer R, any, any> ? R : {}
 
 export type GraphqlResponse<T> = GraphqlServerResponse<T> & GraphqlResponseAdditions
 
 export type GraphqlResponseTyped = GraphqlResponse<GraphqlMiddlewareResponseUnion>
 
 export { serverOptions }
-`
-      });
-    })();
+`;
+      }
+    });
+    const getClientOptionsImport = () => {
+      const clientOptionsPath = appResolver.resolve(
+        "graphqlMiddleware.clientOptions"
+      );
+      if (fileExists(clientOptionsPath)) {
+        const pathRelative = relative(nuxt.options.buildDir, clientOptionsPath);
+        return `import clientOptions from '${pathRelative}'`;
+      }
+    };
+    const clientOptionsImport = getClientOptionsImport();
+    const clientOptionsTemplate = addTemplate({
+      filename: "graphqlMiddleware.clientOptions.mjs",
+      write: true,
+      getContents: () => {
+        if (clientOptionsImport) {
+          return `${clientOptionsImport}
+export { clientOptions }`;
+        }
+        return `export const clientOptions = {}`;
+      }
+    });
+    addTemplate({
+      filename: "graphqlMiddleware.clientOptions.d.ts",
+      write: true,
+      getContents: () => {
+        if (clientOptionsImport) {
+          return `import { GraphqlClientOptions } from '#graphql-middleware/types'
+${clientOptionsImport}
+
+export type GraphqlClientContext = typeof clientOptions extends GraphqlClientOptions<infer R> ? R : {}
+
+export { clientOptions }`;
+        }
+        return `import { GraphqlClientOptions } from '#graphql-middleware/types'
+export const clientOptions: GraphqlClientOptions
+
+export type GraphqlClientContext = {}
+`;
+      }
+    });
+    nuxt.options.alias["#graphql-middleware-client-options"] = clientOptionsTemplate.dst;
     nuxt.options.nitro.externals = nuxt.options.nitro.externals || {};
     nuxt.options.nitro.externals.inline = nuxt.options.nitro.externals.inline || [];
     nuxt.options.nitro.externals.inline.push(template.dst);

package/dist/runtime/clientOptions/index.d.ts

@@ -0,0 +1,2 @@
+import type { GraphqlClientOptions, ContextType } from './../types.js';
+export declare function defineGraphqlClientOptions<T extends ContextType>(options: GraphqlClientOptions<T>): GraphqlClientOptions<T>;

package/dist/runtime/clientOptions/index.js

@@ -0,0 +1,3 @@
+export function defineGraphqlClientOptions(options) {
+  return options;
+}

package/dist/runtime/composables/nuxtApp.js

@@ -1,5 +1,5 @@
 import { useGraphqlState } from "./useGraphqlState.js";
-import { getEndpoint } from "./shared.js";
+import { getEndpoint } from "./../helpers/composables.js";
 import { hash } from "ohash";
 import { GraphqlMiddlewareCache } from "../helpers/ClientCache.js";
 import { useNuxtApp, useAppConfig } from "#imports";

package/dist/runtime/composables/useAsyncGraphqlQuery.d.ts

@@ -1,13 +1,15 @@
-import { type GraphqlMiddlewareQueryName, type KeysOf, type PickFrom } from './shared.js';
+import { type GraphqlMiddlewareQueryName, type KeysOf, type PickFrom } from './../helpers/composables.js';
 import type { FetchOptions } from 'ofetch';
 import { type Ref } from 'vue';
-import type { GraphqlMiddlewareQuery } from '#build/nuxt-graphql-middleware';
+import { type GraphqlClientContext } from '#graphql-middleware-client-options';
+import type { GraphqlMiddlewareQuery } from '#nuxt-graphql-middleware/generated-types';
 import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
 import type { RequestCacheOptions } from '#graphql-middleware/types';
 import type { AsyncData, AsyncDataOptions, NuxtError } from '#app';
 type AsyncGraphqlQueryOptions<ResponseType, DefaultT, Keys extends KeysOf<DefaultT>, F> = AsyncDataOptions<ResponseType, DefaultT, Keys> & {
     graphqlCaching?: RequestCacheOptions;
     fetchOptions?: F;
+    clientContext?: Partial<GraphqlClientContext>;
 };
 /**
  * Wrapper for useAsyncData to perform a single GraphQL query.

package/dist/runtime/composables/useAsyncGraphqlQuery.js

@@ -1,6 +1,12 @@
+import {
+  encodeContext
+} from "./../helpers/composables.js";
 import { isRef, unref } from "vue";
 import { buildRequestParams } from "./../helpers/index.js";
 import { performRequest } from "./nuxtApp.js";
+import {
+  clientOptions
+} from "#graphql-middleware-client-options";
 import { useAsyncData, useAppConfig, useNuxtApp } from "#imports";
 import { hash } from "ohash";
 export function useAsyncGraphqlQuery(name, ...args) {
@@ -28,16 +34,26 @@ export function useAsyncGraphqlQuery(name, ...args) {
   }
   return useAsyncData(
     key,
-    () => performRequest(
-      "query",
-      name,
-      "get",
-      {
-        params: buildRequestParams(unref(variables)),
-        ...fetchOptions
-      },
-      asyncDataOptions.graphqlCaching
-    ),
+    () => {
+      const globalClientContext = clientOptions.buildClientContext ? clientOptions.buildClientContext() : {};
+      return performRequest(
+        "query",
+        name,
+        "get",
+        {
+          ...fetchOptions,
+          params: {
+            ...fetchOptions?.params || {},
+            ...buildRequestParams(unref(variables)),
+            ...encodeContext({
+              ...globalClientContext,
+              ...asyncDataOptions.clientContext || {}
+            })
+          }
+        },
+        asyncDataOptions.graphqlCaching
+      );
+    },
     asyncDataOptions
   );
 }

package/dist/runtime/composables/useGraphqlMutation.d.ts

@@ -1,5 +1,5 @@
-import { type GraphqlMiddlewareMutationName, type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './shared.js';
-import type { GraphqlMiddlewareMutation } from '#build/nuxt-graphql-middleware';
+import { type GraphqlMiddlewareMutationName, type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../helpers/composables.js';
+import type { GraphqlMiddlewareMutation } from '#nuxt-graphql-middleware/generated-types';
 import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
 /**
  * Performs a GraphQL mutation.

package/dist/runtime/composables/useGraphqlMutation.js

@@ -1,8 +1,25 @@
+import {
+  encodeContext
+} from "./../helpers/composables.js";
 import { performRequest } from "./nuxtApp.js";
+import { clientOptions } from "#graphql-middleware-client-options";
 export function useGraphqlMutation(...args) {
-  const [name, body, fetchOptions = {}] = typeof args[0] === "string" ? [args[0], args[1], args[2]?.fetchOptions] : [args[0].name, args[0].variables, args[0].fetchOptions];
+  const [name, body, fetchOptions = {}, overrideClientContext = {}] = typeof args[0] === "string" ? [args[0], args[1], args[2]?.fetchOptions, args[2]?.clientContext] : [
+    args[0].name,
+    args[0].variables,
+    args[0].fetchOptions,
+    args[0].clientContext
+  ];
+  const globalClientContext = clientOptions.buildClientContext ? clientOptions.buildClientContext() : {};
   return performRequest("mutation", name, "post", {
+    ...fetchOptions,
     body,
-    ...fetchOptions
+    params: {
+      ...fetchOptions.params || {},
+      ...encodeContext({
+        ...globalClientContext,
+        ...overrideClientContext
+      })
+    }
   });
 }

package/dist/runtime/composables/useGraphqlQuery.d.ts

@@ -1,5 +1,5 @@
-import { type GraphqlMiddlewareQueryName, type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './shared.js';
-import type { GraphqlMiddlewareQuery } from '#build/nuxt-graphql-middleware';
+import { type GraphqlMiddlewareQueryName, type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './../helpers/composables.js';
+import type { GraphqlMiddlewareQuery } from '#nuxt-graphql-middleware/generated-types';
 import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
 /**
  * Performs a GraphQL query.

package/dist/runtime/composables/useGraphqlQuery.js

@@ -1,19 +1,44 @@
+import {
+  encodeContext
+} from "./../helpers/composables.js";
 import { buildRequestParams } from "./../helpers/index.js";
 import { performRequest } from "./nuxtApp.js";
+import { clientOptions } from "#graphql-middleware-client-options";
 export function useGraphqlQuery(...args) {
-  const [name, variables, fetchOptions = {}, graphqlCaching = {}] = typeof args[0] === "string" ? [args[0], args[1], args[2]?.fetchOptions, args[2]?.graphqlCaching] : [
+  const [
+    name,
+    variables,
+    fetchOptions = {},
+    graphqlCaching = {},
+    overrideClientContext = {}
+  ] = typeof args[0] === "string" ? [
+    args[0],
+    args[1],
+    args[2]?.fetchOptions,
+    args[2]?.graphqlCaching,
+    args[2]?.clientContext
+  ] : [
     args[0].name,
     args[0].variables,
     args[0].fetchOptions,
-    args[0].graphqlCaching
+    args[0].graphqlCaching,
+    args[0].clientContext
   ];
+  const globalClientContext = clientOptions.buildClientContext ? clientOptions.buildClientContext() : {};
   return performRequest(
     "query",
     name,
     "get",
     {
-      params: buildRequestParams(variables),
-      ...fetchOptions
+      ...fetchOptions,
+      params: {
+        ...fetchOptions.params || {},
+        ...buildRequestParams(variables),
+        ...encodeContext({
+          ...globalClientContext,
+          ...overrideClientContext
+        })
+      }
     },
     graphqlCaching
   );

package/dist/runtime/composables/useGraphqlState.d.ts

@@ -1,2 +1,3 @@
+import type { NuxtApp } from '#app';
 import type { GraphqlMiddlewareState } from '#graphql-middleware/types';
-export declare const useGraphqlState: (providedApp?: any) => GraphqlMiddlewareState | null;
+export declare const useGraphqlState: (providedApp?: NuxtApp) => GraphqlMiddlewareState | null;

package/dist/runtime/composables/useGraphqlUploadMutation.d.ts

@@ -1,5 +1,5 @@
-import { type GraphqlMiddlewareMutationName, type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './shared.js';
-import type { GraphqlMiddlewareMutation } from '#build/nuxt-graphql-middleware';
+import { type GraphqlMiddlewareMutationName, type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../helpers/composables.js';
+import type { GraphqlMiddlewareMutation } from '#nuxt-graphql-middleware/generated-types';
 import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
 /**
  * Performs a GraphQL upload mutation.

package/dist/runtime/composables/useGraphqlUploadMutation.js

@@ -1,6 +1,8 @@
 import {
-  getEndpoint
-} from "./shared.js";
+  getEndpoint,
+  encodeContext
+} from "./../helpers/composables.js";
+import { clientOptions } from "#graphql-middleware-client-options";
 import { useGraphqlState } from "#imports";
 function createFormData(variables) {
   const formData = new FormData();
@@ -34,7 +36,12 @@ function createFormData(variables) {
   return formData;
 }
 export function useGraphqlUploadMutation(...args) {
-  const [name, variables, fetchOptions = {}] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].name, args[0].variables, args[0].fetchOptions];
+  const [name, variables, fetchOptions = {}, overrideClientContext = {}] = typeof args[0] === "string" ? [args[0], args[1], args[2]?.fetchOptions, args[2]?.clientContext] : [
+    args[0].name,
+    args[0].variables,
+    args[0].fetchOptions,
+    args[0].clientContext
+  ];
   if (!variables) {
     throw new Error(
       'Using "useGraphqlUploadMutation" without variables is not supported.'
@@ -42,9 +49,18 @@ export function useGraphqlUploadMutation(...args) {
   }
   const state = useGraphqlState();
   const formData = createFormData(variables);
+  const globalClientContext = clientOptions.buildClientContext ? clientOptions.buildClientContext() : {};
+  const clientContext = encodeContext({
+    ...globalClientContext,
+    ...overrideClientContext
+  });
   return $fetch(getEndpoint("upload", name), {
     ...state && state.fetchOptions ? state.fetchOptions : {},
     ...fetchOptions || {},
+    params: {
+      ...clientContext,
+      ...fetchOptions.params || {}
+    },
     method: "POST",
     body: formData
   }).then((v) => {