nuxt-graphql-middleware 4.2.0 → 4.3.1

package/dist/module.mjs

@@ -1,7 +1,7 @@
 import { fileURLToPath } from 'url';
-import { dirname, resolve, relative } from 'pathe';
+import { dirname, resolve, relative, parse as parse$1, join } 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.2.0";
+const version = "4.3.1";
 
 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}
 }
@@ -386,7 +386,7 @@ function logDocuments(logger, documents, logEverything) {
   }
 }
 
-const logger = useLogger("nuxt-graphql-middleware");
+const logger = useLogger(name);
 const defaultOptions = {
   codegenConfig: {
     exportFragmentSpreadSubTypes: true,
@@ -445,7 +445,6 @@ async function autoImportDocuments(patterns = [], srcResolver) {
   if (!patterns.length) {
     return Promise.resolve([]);
   }
-  console.log({ patterns });
   const files = (await resolveFiles(srcResolver(), patterns, {
     followSymbolicLinks: false
   })).filter((path) => {
@@ -543,11 +542,11 @@ async function buildDocuments(providedDocuments = [], autoImportPatterns, resolv
   return documents;
 }
 function parseDocument(document, rootDir) {
-  let name = document.filename ? document.filename.replace(rootDir, "") : "";
-  if (name.charAt(0) === "/") {
-    name = name.slice(1);
+  let name2 = document.filename ? document.filename.replace(rootDir, "") : "";
+  if (name2.charAt(0) === "/") {
+    name2 = name2.slice(1);
   }
-  const source = new Source(document.content, name);
+  const source = new Source(document.content, name2);
   return parse(source);
 }
 function validateDocuments(schema, documents, rootDir) {
@@ -734,7 +733,21 @@ async function outputDocuments(outputPath, documents) {
     }
   });
 }
+async function getOutputDocumentsPath(optionsOutputDocuments, nuxtBuildDir, resolvePath) {
+  if (!optionsOutputDocuments) {
+    return null;
+  }
+  if (typeof optionsOutputDocuments === "boolean") {
+    return resolve(nuxtBuildDir, `${name}/documents`);
+  } else {
+    return await resolvePath(optionsOutputDocuments);
+  }
+}
 
+function pathWithoutExtension(fullPath) {
+  const parsed = parse$1(fullPath);
+  return join(parsed.dir, parsed.name);
+}
 const RPC_NAMESPACE = "nuxt-graphql-middleware";
 const module = defineNuxtModule({
   meta: {
@@ -774,6 +787,7 @@ const module = defineNuxtModule({
     const moduleResolver = createResolver(import.meta.url);
     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(
@@ -828,14 +842,15 @@ const module = defineNuxtModule({
         ctx.templates = templates;
         ctx.documents = documents;
         rpc?.broadcast.documentsUpdated(documents);
-        if (options.outputDocuments) {
-          const destFolder = resolve(
-            nuxt.options.buildDir,
-            "nuxt-graphql-middleware/documents"
-          );
-          outputDocuments(destFolder, documents);
+        const outputDocumentsPath = await getOutputDocumentsPath(
+          options.outputDocuments,
+          nuxt.options.buildDir,
+          rootResolver.resolvePath
+        );
+        if (outputDocumentsPath) {
+          outputDocuments(outputDocumentsPath, documents);
           if (isFirst) {
-            logger.info("Documents generated at " + destFolder);
+            logger.info("Documents generated at " + outputDocumentsPath);
           }
         }
         if (hasErrors) {
@@ -885,37 +900,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({
@@ -929,9 +937,15 @@ const module = defineNuxtModule({
         }
       });
       if (result.dst.includes(GraphqlMiddlewareTemplate.Documents)) {
-        nuxt.options.alias["#graphql-documents"] = result.dst;
+        nuxt.options.alias["#graphql-documents"] = pathWithoutExtension(
+          result.dst
+        );
       } else if (result.dst.includes(GraphqlMiddlewareTemplate.OperationTypes)) {
-        nuxt.options.alias["#graphql-operations"] = result.dst;
+        nuxt.options.alias["#graphql-operations"] = pathWithoutExtension(
+          result.dst
+        );
+      } else if (result.dst.includes(GraphqlMiddlewareTemplate.ComposableContext)) {
+        nuxt.options.alias["#nuxt-graphql-middleware/generated-types"] = pathWithoutExtension(result.dst);
       }
     });
     addTemplate({
@@ -942,7 +956,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 = {
@@ -1003,11 +1017,11 @@ export { serverOptions }
         return `
 import type { GraphqlMiddlewareServerOptions } from '${moduleTypesPath}'
 ${serverOptionsLineTypes}
-import type { GraphqlServerResponse } from '#graphql-middleware/types'
-import type { GraphqlMiddlewareResponseUnion } from '#build/nuxt-graphql-middleware'
+import type { GraphqlServerResponse } from '${runtimeTypesPath}'
+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
 
@@ -1017,11 +1031,58 @@ 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 = {}`;
+      }
+    });
+    const runtimeTypesPath = relative(
+      nuxt.options.buildDir,
+      moduleResolver.resolve("./runtime/types.ts")
+    );
+    addTemplate({
+      filename: "graphqlMiddleware.clientOptions.d.ts",
+      write: true,
+      getContents: () => {
+        if (clientOptionsImport) {
+          return `import type { GraphqlClientOptions } from '${runtimeTypesPath}'
+${clientOptionsImport}
+
+export type GraphqlClientContext = typeof clientOptions extends GraphqlClientOptions<infer R> ? R : {}
+
+export { clientOptions }`;
+        }
+        return `import type { GraphqlClientOptions } from '${runtimeTypesPath}'
+export const clientOptions: GraphqlClientOptions
+
+export type GraphqlClientContext = {}
+`;
+      }
+    });
+    nuxt.options.alias["#graphql-middleware-client-options"] = pathWithoutExtension(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);
-    nuxt.options.alias["#graphql-middleware-server-options-build"] = template.dst;
-    nuxt.options.alias["#graphql-middleware/types"] = moduleResolver.resolve("./runtime/types");
+    nuxt.options.alias["#graphql-middleware-server-options-build"] = pathWithoutExtension(template.dst);
+    nuxt.options.alias["#graphql-middleware/types"] = pathWithoutExtension(
+      moduleResolver.resolve("./runtime/types.ts")
+    );
     addServerHandler({
       handler: moduleResolver.resolve("./runtime/serverHandler/index"),
       route: options.serverApiPrefix + "/:operation/:name"

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/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) => {

package/dist/runtime/{composables/shared.d.ts → helpers/composables.d.ts}

@@ -1,11 +1,13 @@
 import type { FetchOptions } from 'ofetch';
-import type { GraphqlMiddlewareQuery, GraphqlMiddlewareMutation } from '#build/nuxt-graphql-middleware';
+import type { GraphqlMiddlewareQuery, GraphqlMiddlewareMutation } from '#nuxt-graphql-middleware/generated-types';
 import type { RequestCacheOptions } from '#graphql-middleware/types';
+import type { GraphqlClientContext } from '#graphql-middleware-client-options';
 export type GraphqlMiddlewareQueryName = keyof GraphqlMiddlewareQuery;
 export type GraphqlMiddlewareMutationName = keyof GraphqlMiddlewareMutation;
 export type GraphqlComposableOptions = {
     fetchOptions?: FetchOptions;
     graphqlCaching?: RequestCacheOptions;
+    clientContext?: Partial<GraphqlClientContext>;
 };
 export type GetQueryArgs<T extends GraphqlMiddlewareQueryName, M extends GraphqlMiddlewareQuery> = M[T][0] extends null ? [T, (null | undefined)?, GraphqlComposableOptions?] : M[T][1] extends false ? [T, M[T][0], GraphqlComposableOptions?] : [T, M[T][0]?, GraphqlComposableOptions?];
 export type GetMutationArgs<T extends GraphqlMiddlewareMutationName, M extends GraphqlMiddlewareMutation> = M[T][0] extends null ? [T, (null | undefined)?, GraphqlComposableOptions?] : M[T][1] extends false ? [T, M[T][0], GraphqlComposableOptions?] : [T, M[T][0]?, GraphqlComposableOptions?];
@@ -16,21 +18,26 @@ export type QueryObjectArgs<T extends GraphqlMiddlewareQueryName, M extends Grap
     name: T;
     fetchOptions?: FetchOptions;
     graphqlCaching?: RequestCacheOptions;
+    clientContext?: Partial<GraphqlClientContext>;
     variables?: null;
 } : {
     name: T;
     variables: M[T][0];
     fetchOptions?: FetchOptions;
     graphqlCaching?: RequestCacheOptions;
+    clientContext?: Partial<GraphqlClientContext>;
 };
 export type MutationObjectArgs<T extends GraphqlMiddlewareMutationName, M extends GraphqlMiddlewareMutation> = M[T][0] extends null ? {
     name: T;
     variables?: null;
     fetchOptions?: FetchOptions;
+    clientContext?: Partial<GraphqlClientContext>;
 } : {
     name: T;
     variables: M[T][0];
     fetchOptions?: FetchOptions;
+    clientContext?: Partial<GraphqlClientContext>;
 };
 export type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : K[number] extends never ? T : Pick<T, K[number]> : T;
 export type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
+export declare function encodeContext(context: Record<string, string | null | undefined>): Record<string, string>;

package/dist/runtime/helpers/composables.js

@@ -0,0 +1,17 @@
+import { useRuntimeConfig } from "#imports";
+import { CLIENT_CONTEXT_PREFIX } from "../settings/index.js";
+export function getEndpoint(operation, operationName) {
+  const config = useRuntimeConfig();
+  return `${config?.public?.["nuxt-graphql-middleware"]?.serverApiPrefix}/${operation}/${operationName}`;
+}
+export function encodeContext(context) {
+  return Object.entries(context).reduce(
+    (acc, [key, value]) => {
+      if (typeof value === "string") {
+        acc[CLIENT_CONTEXT_PREFIX + key] = value;
+      }
+      return acc;
+    },
+    {}
+  );
+}

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/server/utils/index.d.ts

@@ -0,0 +1,3 @@
+import type { FetchOptions } from 'ofetch';
+import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
+export declare function performRequest<T>(operation: string, operationName: string, method: 'get' | 'post', options: FetchOptions): Promise<GraphqlResponse<T>>;

package/dist/runtime/server/utils/index.js

@@ -0,0 +1,12 @@
+import { getEndpoint } from "./../../helpers/composables.js";
+export function performRequest(operation, operationName, method, options) {
+  return $fetch(getEndpoint(operation, operationName), {
+    ...options,
+    method
+  }).then((v) => {
+    return {
+      data: v.data,
+      errors: v.errors || []
+    };
+  });
+}

package/dist/runtime/server/utils/useGraphqlMutation.d.ts

@@ -0,0 +1,7 @@
+import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
+import { type GraphqlMiddlewareMutationName, type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../../helpers/composables.js';
+import type { GraphqlMiddlewareMutation } from '#nuxt-graphql-middleware/generated-types';
+/**
+ * Performs a GraphQL mutation.
+ */
+export declare function useGraphqlMutation<T extends GraphqlMiddlewareMutationName, R extends GetMutationResult<T, GraphqlMiddlewareMutation>>(...args: GetMutationArgs<T, GraphqlMiddlewareMutation> | [MutationObjectArgs<T, GraphqlMiddlewareMutation>]): Promise<GraphqlResponse<R>>;

package/dist/runtime/server/utils/useGraphqlMutation.js

@@ -0,0 +1,20 @@
+import {
+  encodeContext
+} from "./../../helpers/composables.js";
+import { performRequest } from "./index.js";
+export function useGraphqlMutation(...args) {
+  const [name, body, fetchOptions = {}, clientContext = {}] = 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
+  ];
+  return performRequest("mutation", name, "post", {
+    ...fetchOptions,
+    body,
+    params: {
+      ...encodeContext(clientContext),
+      ...fetchOptions.params || {}
+    }
+  });
+}

package/dist/runtime/server/utils/useGraphqlQuery.d.ts

@@ -0,0 +1,7 @@
+import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
+import { type GraphqlMiddlewareQueryName, type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './../../helpers/composables.js';
+import type { GraphqlMiddlewareQuery } from '#nuxt-graphql-middleware/generated-types';
+/**
+ * Performs a GraphQL query.
+ */
+export declare function useGraphqlQuery<T extends GraphqlMiddlewareQueryName, R extends GetQueryResult<T, GraphqlMiddlewareQuery>>(...args: GetQueryArgs<T, GraphqlMiddlewareQuery> | [QueryObjectArgs<T, GraphqlMiddlewareQuery>]): Promise<GraphqlResponse<R>>;

package/dist/runtime/server/utils/useGraphqlQuery.js

@@ -0,0 +1,21 @@
+import {
+  encodeContext
+} from "./../../helpers/composables.js";
+import { buildRequestParams } from "./../../helpers/index.js";
+import { performRequest } from "./index.js";
+export function useGraphqlQuery(...args) {
+  const [name, variables, fetchOptions = {}, clientContext = {}] = 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
+  ];
+  return performRequest("query", name, "get", {
+    ...fetchOptions,
+    params: {
+      ...fetchOptions.params || {},
+      ...buildRequestParams(variables),
+      ...encodeContext(clientContext)
+    }
+  });
+}