nuxt-graphql-middleware 4.0.0 → 4.1.0

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

@@ -1,10 +1,11 @@
-import { type GraphqlMiddlewareQueryName, type GetQueryArgs, type QueryObjectArgs, type GetQueryResult, type GraphqlMiddlewareMutationName, type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './shared';
+import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
+import { type GraphqlMiddlewareQueryName, type GetQueryArgs, type QueryObjectArgs, type GetQueryResult, type GraphqlMiddlewareMutationName, type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './shared.js';
 import type { GraphqlMiddlewareQuery, GraphqlMiddlewareMutation } from '#build/nuxt-graphql-middleware';
 /**
  * Performs a GraphQL query.
  */
-export declare function useGraphqlQuery<T extends GraphqlMiddlewareQueryName>(...args: GetQueryArgs<T, GraphqlMiddlewareQuery> | [QueryObjectArgs<T, GraphqlMiddlewareQuery>]): Promise<GetQueryResult<T, GraphqlMiddlewareQuery>>;
+export declare function useGraphqlQuery<T extends GraphqlMiddlewareQueryName, R extends GetQueryResult<T, GraphqlMiddlewareQuery>>(...args: GetQueryArgs<T, GraphqlMiddlewareQuery> | [QueryObjectArgs<T, GraphqlMiddlewareQuery>]): Promise<GraphqlResponse<R>>;
 /**
  * Performs a GraphQL mutation.
  */
-export declare function useGraphqlMutation<T extends GraphqlMiddlewareMutationName>(...args: GetMutationArgs<T, GraphqlMiddlewareMutation> | [MutationObjectArgs<T, GraphqlMiddlewareMutation>]): Promise<GetMutationResult<T, GraphqlMiddlewareMutation>>;
+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/composables/{server.mjs → server.js}

@@ -1,7 +1,7 @@
 import {
   getEndpoint
-} from "./shared.mjs";
-import { buildRequestParams } from "./../helpers/index.mjs";
+} from "./shared.js";
+import { buildRequestParams } from "./../helpers/index.js";
 function performRequest(operation, operationName, method, options) {
   return $fetch(getEndpoint(operation, operationName), {
     ...options,

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

@@ -1,24 +1,27 @@
 import type { FetchOptions } from 'ofetch';
 import type { GraphqlMiddlewareQuery, GraphqlMiddlewareMutation } from '#build/nuxt-graphql-middleware';
+import type { RequestCacheOptions } from '#graphql-middleware/types';
 export type GraphqlMiddlewareQueryName = keyof GraphqlMiddlewareQuery;
 export type GraphqlMiddlewareMutationName = keyof GraphqlMiddlewareMutation;
-export type GetQueryArgs<T extends GraphqlMiddlewareQueryName, M extends GraphqlMiddlewareQuery> = M[T][0] extends null ? [T] : M[T][1] extends false ? [T, M[T][0]] : [T, M[T][0]?];
-export type GetMutationArgs<T extends GraphqlMiddlewareMutationName, M extends GraphqlMiddlewareMutation> = M[T][0] extends null ? [T] : M[T][1] extends false ? [T, M[T][0]] : [T, M[T][0]?];
-export type GraphqlResponse<T> = {
-    data: T;
-    errors: any[];
+export type GraphqlComposableOptions = {
+    fetchOptions?: FetchOptions;
+    graphqlCaching?: RequestCacheOptions;
 };
-export type GetQueryResult<T extends GraphqlMiddlewareQueryName, M extends GraphqlMiddlewareQuery> = M[T] extends undefined ? undefined : GraphqlResponse<M[T][2]>;
-export type GetMutationResult<T extends GraphqlMiddlewareMutationName, M extends GraphqlMiddlewareMutation> = M[T] extends undefined ? undefined : GraphqlResponse<M[T][2]>;
+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?];
+export type GetQueryResult<T extends GraphqlMiddlewareQueryName, M extends GraphqlMiddlewareQuery> = M[T] extends undefined ? undefined : M[T][2];
+export type GetMutationResult<T extends GraphqlMiddlewareMutationName, M extends GraphqlMiddlewareMutation> = M[T] extends undefined ? undefined : M[T][2];
 export declare function getEndpoint(operation: string, operationName: string): string;
 export type QueryObjectArgs<T extends GraphqlMiddlewareQueryName, M extends GraphqlMiddlewareQuery> = M[T][0] extends null ? {
     name: T;
     fetchOptions?: FetchOptions;
+    graphqlCaching?: RequestCacheOptions;
     variables?: null;
 } : {
     name: T;
     variables: M[T][0];
     fetchOptions?: FetchOptions;
+    graphqlCaching?: RequestCacheOptions;
 };
 export type MutationObjectArgs<T extends GraphqlMiddlewareMutationName, M extends GraphqlMiddlewareMutation> = M[T][0] extends null ? {
     name: T;
@@ -29,3 +32,5 @@ export type MutationObjectArgs<T extends GraphqlMiddlewareMutationName, M extend
     variables: M[T][0];
     fetchOptions?: FetchOptions;
 };
+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>;

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

@@ -0,0 +1,22 @@
+import { type GraphqlMiddlewareQueryName, type KeysOf, type PickFrom } from './shared.js';
+import type { FetchOptions } from 'ofetch';
+import { type Ref } from 'vue';
+import type { GraphqlMiddlewareQuery } from '#build/nuxt-graphql-middleware';
+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;
+};
+/**
+ * Wrapper for useAsyncData to perform a single GraphQL query.
+ */
+export declare function useAsyncGraphqlQuery<Name extends GraphqlMiddlewareQueryName, VarType extends GraphqlMiddlewareQuery[Name][0], VarsOptional extends GraphqlMiddlewareQuery[Name][1], ResponseType extends GraphqlResponse<GraphqlMiddlewareQuery[Name][2]>, F extends FetchOptions<'json'>, DefaultT = ResponseType, Keys extends KeysOf<DefaultT> = KeysOf<DefaultT>>(name: Name, ...args: VarsOptional extends true ? [
+    (undefined | null | Record<string, never> | VarType | Ref<VarType>)?,
+    AsyncGraphqlQueryOptions<ResponseType, DefaultT, Keys, F>?
+] : [
+    VarType | Ref<VarType>,
+    (undefined | null | AsyncGraphqlQueryOptions<ResponseType, DefaultT, Keys, F>)?
+]): AsyncData<PickFrom<DefaultT, KeysOf<DefaultT>> | null, NuxtError<unknown> | null>;
+export {};

package/dist/runtime/composables/useAsyncGraphqlQuery.js

@@ -0,0 +1,43 @@
+import { isRef, unref } from "vue";
+import { buildRequestParams } from "./../helpers/index.js";
+import { performRequest } from "./nuxtApp.js";
+import { useAsyncData, useAppConfig, useNuxtApp } from "#imports";
+import { hash } from "ohash";
+export function useAsyncGraphqlQuery(name, ...args) {
+  const variables = args[0];
+  const asyncDataOptions = args[1] || {};
+  const fetchOptions = asyncDataOptions.fetchOptions;
+  const key = `graphql:${name}:${hash(unref(variables))}`;
+  const config = useAppConfig();
+  const app = useNuxtApp();
+  if (import.meta.client) {
+    if (variables && isRef(variables)) {
+      if (!asyncDataOptions.watch) {
+        asyncDataOptions.watch = [];
+      }
+      asyncDataOptions.watch.push(variables);
+    }
+    if (asyncDataOptions.graphqlCaching?.client && !asyncDataOptions.getCachedData) {
+      asyncDataOptions.getCachedData = function(key2) {
+        if (!app.isHydrating && !config.graphqlMiddleware.clientCacheEnabled) {
+          return;
+        }
+        return app.payload.data[key2];
+      };
+    }
+  }
+  return useAsyncData(
+    key,
+    () => performRequest(
+      "query",
+      name,
+      "get",
+      {
+        params: buildRequestParams(unref(variables)),
+        ...fetchOptions
+      },
+      asyncDataOptions.graphqlCaching
+    ),
+    asyncDataOptions
+  );
+}

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

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

@@ -1,6 +1,6 @@
-import { performRequest } from "./nuxtApp.mjs";
+import { performRequest } from "./nuxtApp.js";
 export function useGraphqlMutation(...args) {
-  const [name, body, fetchOptions = {}] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].name, args[0].variables, args[0].fetchOptions];
+  const [name, body, fetchOptions = {}] = typeof args[0] === "string" ? [args[0], args[1], args[2]?.fetchOptions] : [args[0].name, args[0].variables, args[0].fetchOptions];
   return performRequest("mutation", name, "post", {
     body,
     ...fetchOptions

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

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

@@ -0,0 +1,20 @@
+import { buildRequestParams } from "./../helpers/index.js";
+import { performRequest } from "./nuxtApp.js";
+export function useGraphqlQuery(...args) {
+  const [name, variables, fetchOptions = {}, graphqlCaching = {}] = typeof args[0] === "string" ? [args[0], args[1], args[2]?.fetchOptions, args[2]?.graphqlCaching] : [
+    args[0].name,
+    args[0].variables,
+    args[0].fetchOptions,
+    args[0].graphqlCaching
+  ];
+  return performRequest(
+    "query",
+    name,
+    "get",
+    {
+      params: buildRequestParams(variables),
+      ...fetchOptions
+    },
+    graphqlCaching
+  );
+}

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

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

package/dist/runtime/composables/{useGraphqlState.mjs → useGraphqlState.js}

@@ -1,4 +1,4 @@
-import { useNuxtApp } from "#app";
+import { useNuxtApp } from "#imports";
 export const useGraphqlState = function(providedApp) {
   try {
     const app = providedApp || useNuxtApp();

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

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

package/dist/runtime/composables/useGraphqlUploadMutation.js

@@ -0,0 +1,57 @@
+import {
+  getEndpoint
+} from "./shared.js";
+import { useGraphqlState } from "#imports";
+function createFormData(variables) {
+  const formData = new FormData();
+  formData.append("operations", "{}");
+  const map = {};
+  let fileIndex = 0;
+  const traverseAndBuildMap = (obj, path) => {
+    if (obj instanceof File) {
+      const fileKey = `${fileIndex++}`;
+      map[fileKey] = [path];
+      formData.append(fileKey, obj);
+      return null;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map(
+        (item, index) => traverseAndBuildMap(item, `${path}.${index}`)
+      );
+    }
+    if (typeof obj === "object" && obj !== null) {
+      const newObj = {};
+      for (const key in obj) {
+        newObj[key] = traverseAndBuildMap(obj[key], `${path}.${key}`);
+      }
+      return newObj;
+    }
+    return obj;
+  };
+  const cleanedVariables = traverseAndBuildMap(variables, "variables");
+  formData.append("variables", JSON.stringify(cleanedVariables));
+  formData.append("map", JSON.stringify(map));
+  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];
+  if (!variables) {
+    throw new Error(
+      'Using "useGraphqlUploadMutation" without variables is not supported.'
+    );
+  }
+  const state = useGraphqlState();
+  const formData = createFormData(variables);
+  return $fetch(getEndpoint("upload", name), {
+    ...state && state.fetchOptions ? state.fetchOptions : {},
+    ...fetchOptions || {},
+    method: "POST",
+    body: formData
+  }).then((v) => {
+    return {
+      ...v,
+      data: v?.data,
+      errors: v?.errors || []
+    };
+  });
+}

package/dist/runtime/helpers/ClientCache.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Simple LRU (least recently used) cache.
+ *
+ * Keeps the amount of cached items limited to the given max size.
+ * Once that number is reached, the cache item used the least is removed.
+ */
+export declare class GraphqlMiddlewareCache {
+    cache: Record<string, unknown>;
+    keys: string[];
+    maxSize: number;
+    constructor(maxSize?: number);
+    set(key: string, value: unknown): void;
+    get<T>(key: string): T | undefined;
+    purge(): void;
+}

package/dist/runtime/helpers/ClientCache.js

@@ -0,0 +1,40 @@
+export class GraphqlMiddlewareCache {
+  cache;
+  keys;
+  maxSize;
+  constructor(maxSize = 100) {
+    this.cache = {};
+    this.keys = [];
+    this.maxSize = maxSize;
+  }
+  set(key, value) {
+    if (Object.prototype.hasOwnProperty.call(this.cache, key)) {
+      const index = this.keys.indexOf(key);
+      if (index > -1) {
+        this.keys.splice(index, 1);
+      }
+    } else if (this.keys.length >= this.maxSize) {
+      const oldestKey = this.keys.shift();
+      if (oldestKey !== void 0) {
+        delete this.cache[oldestKey];
+      }
+    }
+    this.cache[key] = value;
+    this.keys.push(key);
+  }
+  get(key) {
+    const value = this.cache[key];
+    if (value !== void 0) {
+      const index = this.keys.indexOf(key);
+      if (index > -1) {
+        this.keys.splice(index, 1);
+        this.keys.push(key);
+      }
+      return value;
+    }
+    return void 0;
+  }
+  purge() {
+    this.cache = {};
+  }
+}

package/dist/runtime/helpers/{index.mjs → index.js}

@@ -2,7 +2,7 @@ export function falsy(value) {
   return value !== null && value !== void 0;
 }
 export function buildRequestParams(variables) {
-  if (!variables) {
+  if (typeof variables !== "object" || !variables) {
     return {};
   }
   for (const key in variables) {

package/dist/runtime/plugins/provideState.d.ts

@@ -1,5 +1,5 @@
 /**
  * Create and provide the state singleton for the composables.
  */
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/plugins/provideState.js

@@ -0,0 +1,17 @@
+import { defineNuxtPlugin } from "#imports";
+export default defineNuxtPlugin({
+  name: "nuxt-graphql-middleware-provide-state",
+  // We can set a very low order to make sure this plugin runs as early as
+  // possible.
+  order: -9999,
+  setup() {
+    const graphqlState = {
+      fetchOptions: {}
+    };
+    return {
+      provide: {
+        graphqlState
+      }
+    };
+  }
+});

package/dist/runtime/serverHandler/helpers/index.d.ts

@@ -1,8 +1,9 @@
 import { type QueryObject } from 'ufo';
 import type { H3Event } from 'h3';
 import type { FetchOptions, FetchResponse, FetchError } from 'ofetch';
-import type { GraphqlMiddlewareRuntimeConfig, GraphqlMiddlewareServerOptions } from './../../../types';
-import { GraphqlMiddlewareOperation } from './../../settings';
+import type { GraphqlMiddlewareRuntimeConfig, GraphqlMiddlewareServerOptions } from './../../../types.js';
+import { GraphqlMiddlewareOperation } from './../../settings.js';
+import { type Documents } from '#graphql-documents';
 export declare function queryParamToVariables(query: QueryObject): any;
 /**
  * Get the URL of the GraphQL endpoint.
@@ -12,10 +13,11 @@ export declare function getEndpoint(config: GraphqlMiddlewareRuntimeConfig, serv
  * Get the options for the $fetch request to the GraphQL server.
  */
 export declare function getFetchOptions(serverOptions: GraphqlMiddlewareServerOptions, event: H3Event, operation: GraphqlMiddlewareOperation, operationName: string): FetchOptions | Promise<FetchOptions>;
+export declare function throwError(statusMessage: string, statusCode?: number): never;
 /**
  * Assure that the request is valid.
  */
-export declare function validateRequest(method?: string, operation?: GraphqlMiddlewareOperation, name?: string, documents?: Record<string, Record<string, string>>): void;
+export declare function validateRequest(method?: string, operation?: GraphqlMiddlewareOperation | string, name?: string, documents?: Documents): void;
 /**
  * Handle GraphQL server response.
  */

package/dist/runtime/serverHandler/helpers/{index.mjs → index.js}

@@ -1,5 +1,5 @@
 import { createError } from "h3";
-import { GraphqlMiddlewareOperation } from "./../../settings/index.mjs";
+import { GraphqlMiddlewareOperation } from "./../../settings/index.js";
 export function queryParamToVariables(query) {
   try {
     if (query.__variables && typeof query.__variables === "string") {
@@ -31,7 +31,7 @@ export function getFetchOptions(serverOptions, event, operation, operationName)
   }
   return {};
 }
-function throwError(statusMessage, statusCode = 400) {
+export function throwError(statusMessage, statusCode = 400) {
   throw createError({
     statusCode,
     statusMessage

package/dist/runtime/serverHandler/{index.mjs → index.js}

@@ -6,10 +6,10 @@ import {
   validateRequest,
   onServerResponse,
   onServerError
-} from "./helpers/index.mjs";
-import { GraphqlMiddlewareOperation } from "./../settings/index.mjs";
+} from "./helpers/index.js";
+import { GraphqlMiddlewareOperation } from "./../settings/index.js";
 import { documents } from "#graphql-documents";
-import serverOptions from "#graphql-middleware-server-options-build";
+import { serverOptions } from "#graphql-middleware-server-options-build";
 import { useRuntimeConfig } from "#imports";
 export default defineEventHandler(async (event) => {
   const method = event.method;

package/dist/runtime/serverHandler/upload.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/serverHandler/upload.js

@@ -0,0 +1,101 @@
+import {
+  defineEventHandler,
+  readMultipartFormData
+} from "h3";
+import {
+  getEndpoint,
+  getFetchOptions,
+  validateRequest,
+  onServerResponse,
+  onServerError,
+  throwError
+} from "./helpers/index.js";
+import { GraphqlMiddlewareOperation } from "./../settings/index.js";
+import { documents } from "#graphql-documents";
+import { serverOptions } from "#graphql-middleware-server-options-build";
+import { useRuntimeConfig } from "#imports";
+function parseMultipart(data) {
+  const files = data.filter((v) => !!v.filename);
+  const variablesData = data.find((v) => v.name === "variables")?.data?.toString();
+  if (!variablesData) {
+    throw new Error("Missing variables in form data.");
+  }
+  const variables = JSON.parse(variablesData);
+  const map = data.find((v) => v.name === "map")?.data.toString() || "{}";
+  return { files, map, variables };
+}
+export default defineEventHandler(async (event) => {
+  const method = event.method;
+  const operation = GraphqlMiddlewareOperation.Mutation;
+  const operationName = event.context?.params?.name;
+  validateRequest(method, operation, operationName, documents);
+  const operationDocument = documents[operation][operationName];
+  const multiPartData = await readMultipartFormData(event);
+  if (!multiPartData) {
+    return throwError("Failed to read multi part data.");
+  }
+  const { variables, map, files } = parseMultipart(multiPartData);
+  const formData = new FormData();
+  formData.append(
+    "operations",
+    JSON.stringify({
+      query: operationDocument,
+      variables,
+      operationName
+    })
+  );
+  formData.append("map", map);
+  for (const file of files) {
+    if (!file.name) {
+      return throwError("Missing name for file: " + file.filename);
+    }
+    const blob = new Blob([file.data]);
+    formData.append(file.name, blob, file.filename);
+  }
+  if (serverOptions.doGraphqlRequest) {
+    return serverOptions.doGraphqlRequest({
+      event,
+      operation,
+      operationName,
+      operationDocument,
+      variables,
+      formData
+    });
+  }
+  const runtimeConfig = useRuntimeConfig().graphqlMiddleware;
+  const endpoint = await getEndpoint(
+    runtimeConfig,
+    serverOptions,
+    event,
+    operation,
+    operationName
+  );
+  const fetchOptions = await getFetchOptions(
+    serverOptions,
+    event,
+    operation,
+    operationName
+  );
+  return $fetch.raw(endpoint, {
+    ...fetchOptions,
+    // @todo: Remove any once https://github.com/unjs/nitro/pull/883 is released.
+    method: "POST",
+    body: formData
+  }).then((response) => {
+    return onServerResponse(
+      serverOptions,
+      event,
+      response,
+      operation,
+      operationName
+    );
+  }).catch((error) => {
+    return onServerError(
+      serverOptions,
+      event,
+      error,
+      operation,
+      operationName
+    );
+  });
+});

package/dist/runtime/serverOptions/defineGraphqlServerOptions.d.ts

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

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

@@ -1,2 +1,2 @@
-import { defineGraphqlServerOptions } from './defineGraphqlServerOptions';
+import { defineGraphqlServerOptions } from './defineGraphqlServerOptions.js';
 export { defineGraphqlServerOptions };

package/dist/runtime/serverOptions/{index.mjs → index.js}

@@ -1,2 +1,2 @@
-import { defineGraphqlServerOptions } from "./defineGraphqlServerOptions.mjs";
+import { defineGraphqlServerOptions } from "./defineGraphqlServerOptions.js";
 export { defineGraphqlServerOptions };

package/dist/runtime/types.d.ts

@@ -0,0 +1,24 @@
+import type { FetchOptions, FetchContext } from 'ofetch';
+import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
+import type { GraphqlMiddlewareResponseUnion } from '#build/nuxt-graphql-middleware';
+export type GraphqlResponseErrorLocation = {
+    line: number;
+    column: number;
+};
+export type GraphqlResponseError = {
+    message: string;
+    locations: GraphqlResponseErrorLocation[];
+    path: string[];
+};
+export type GraphqlServerResponse<T> = {
+    data: T;
+    errors: GraphqlResponseError[];
+};
+export interface GraphqlMiddlewareState {
+    fetchOptions: Omit<FetchOptions<'json'>, 'onResponse'> & {
+        onResponse?: (context: FetchContext<GraphqlResponse<GraphqlMiddlewareResponseUnion>>) => void | Promise<void>;
+    };
+}
+export type RequestCacheOptions = {
+    client?: boolean;
+};

package/dist/types.d.mts

@@ -1,18 +1,11 @@
-
-import type { ModuleOptions, ModuleHooks } from './module.js'
-
+import type { ModuleHooks } from './module.js'
 
 declare module '@nuxt/schema' {
-  interface NuxtConfig { ['graphqlMiddleware']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['graphqlMiddleware']?: ModuleOptions }
   interface NuxtHooks extends ModuleHooks {}
 }
 
 declare module 'nuxt/schema' {
-  interface NuxtConfig { ['graphqlMiddleware']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['graphqlMiddleware']?: ModuleOptions }
   interface NuxtHooks extends ModuleHooks {}
 }
 
-
-export type { GraphqlMiddlewareServerOptions, ModuleHooks, ModuleOptions, default } from './module.js'
+export { type GraphqlMiddlewareServerOptions, type ModuleHooks, type ModuleOptions, default } from './module.js'

package/dist/types.d.ts

@@ -1,18 +1,11 @@
-
-import type { ModuleOptions, ModuleHooks } from './module'
-
+import type { ModuleHooks } from './module'
 
 declare module '@nuxt/schema' {
-  interface NuxtConfig { ['graphqlMiddleware']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['graphqlMiddleware']?: ModuleOptions }
   interface NuxtHooks extends ModuleHooks {}
 }
 
 declare module 'nuxt/schema' {
-  interface NuxtConfig { ['graphqlMiddleware']?: Partial<ModuleOptions> }
-  interface NuxtOptions { ['graphqlMiddleware']?: ModuleOptions }
   interface NuxtHooks extends ModuleHooks {}
 }
 
-
-export type { GraphqlMiddlewareServerOptions, ModuleHooks, ModuleOptions, default } from './module'
+export { type GraphqlMiddlewareServerOptions, type ModuleHooks, type ModuleOptions, default } from './module'