nuxt-graphql-middleware 5.0.0-alpha.0 → 5.0.0-alpha.10

package/dist/runtime/server/api/query.js

@@ -0,0 +1,29 @@
+import { defineEventHandler, getQuery, getRouterParam } from "h3";
+import {
+  queryParamToVariables,
+  extractRequestContext,
+  isValidQuery,
+  throwError
+} from "./../helpers/index.js";
+import { GraphqlMiddlewareOperation } from "./../../settings/index.js";
+import { documents } from "#nuxt-graphql-middleware/documents";
+import { doGraphqlRequest } from "../utils/doGraphqlRequest.js";
+export default defineEventHandler(async (event) => {
+  const operationName = getRouterParam(event, "name");
+  if (!isValidQuery(operationName)) {
+    return throwError("Invalid query name.");
+  }
+  const operationDocument = documents.query[operationName];
+  const queryParams = getQuery(event);
+  const context = extractRequestContext(queryParams);
+  const variables = queryParamToVariables(queryParams);
+  return doGraphqlRequest(
+    {
+      query: operationDocument,
+      variables,
+      operation: GraphqlMiddlewareOperation.Query
+    },
+    context,
+    event
+  );
+});

package/dist/runtime/server/api/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 → server/api}/upload.js

@@ -1,21 +1,22 @@
 import {
   defineEventHandler,
   readMultipartFormData,
-  getQuery
+  getQuery,
+  getRouterParam
 } from "h3";
 import {
   getEndpoint,
   getFetchOptions,
-  validateRequest,
   onServerResponse,
   onServerError,
   throwError,
-  extractRequestContext
-} from "./helpers/index.js";
-import { GraphqlMiddlewareOperation } from "./../settings/index.js";
-import { operations } from "#graphql-documents";
-import { serverOptions } from "#graphql-middleware-server-options-build";
+  extractRequestContext,
+  isValidMutation
+} from "./../helpers/index.js";
+import { documents } from "#nuxt-graphql-middleware/documents";
+import { serverOptions } from "#nuxt-graphql-middleware/server-options";
 import { useRuntimeConfig } from "#imports";
+import { GraphqlMiddlewareOperation } from "../../settings/index.js";
 function parseMultipart(data) {
   const files = data.filter((v) => !!v.filename);
   const variablesData = data.find((v) => v.name === "variables")?.data?.toString();
@@ -27,11 +28,12 @@ function parseMultipart(data) {
   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, operations);
-  const operationDocument = operations[operation][operationName];
+  const operationName = getRouterParam(event, "name");
+  if (!isValidMutation(operationName)) {
+    return throwError("Invalid mutation name.");
+  }
+  const operationDocument = documents.mutation[operationName];
   const multiPartData = await readMultipartFormData(event);
   if (!multiPartData) {
     return throwError("Failed to read multi part data.");

package/dist/runtime/{serverHandler → server}/helpers/index.d.ts

@@ -1,9 +1,11 @@
-import { type QueryObject } from 'ufo';
+import type { QueryObject } from 'ufo';
 import type { H3Event } from 'h3';
 import type { FetchOptions, FetchResponse, FetchError } from 'ofetch';
-import type { GraphqlMiddlewareRequestContext, GraphqlMiddlewareRuntimeConfig, GraphqlMiddlewareServerOptions } from './../../../types.js';
-import { GraphqlMiddlewareOperation } from './../../settings/index.js';
-import { type Operations } from '#graphql-documents';
+import type { GraphqlMiddlewareRequestContext, GraphqlMiddlewareRuntimeConfig, GraphqlMiddlewareServerOptions } from './../../types.js';
+import { type GraphqlMiddlewareOperation } from './../../settings/index.js';
+import type { Mutation, Query } from '#nuxt-graphql-middleware/operation-types';
+export declare function isValidMutation(v?: string): v is keyof Mutation;
+export declare function isValidQuery(v?: string): v is keyof Query;
 export declare function queryParamToVariables(query: QueryObject): any;
 /**
  * Extract the client context from the query params.
@@ -12,21 +14,17 @@ export declare function extractRequestContext(query: QueryObject): GraphqlMiddle
 /**
  * Get the URL of the GraphQL endpoint.
  */
-export declare function getEndpoint(config: GraphqlMiddlewareRuntimeConfig, serverOptions: GraphqlMiddlewareServerOptions<any, any>, event: H3Event, operation: GraphqlMiddlewareOperation, operationName: string, context: GraphqlMiddlewareRequestContext<any>): string | Promise<string>;
+export declare function getEndpoint(config: GraphqlMiddlewareRuntimeConfig, serverOptions: GraphqlMiddlewareServerOptions<any, any>, event: H3Event, operation: GraphqlMiddlewareOperation | null, operationName: string | null, context: GraphqlMiddlewareRequestContext<any> | null): string | Promise<string>;
 /**
  * Get the options for the $fetch request to the GraphQL server.
  */
-export declare function getFetchOptions(serverOptions: GraphqlMiddlewareServerOptions<any, any>, event: H3Event, operation: GraphqlMiddlewareOperation, operationName: string, context: GraphqlMiddlewareRequestContext<any>): FetchOptions | Promise<FetchOptions>;
+export declare function getFetchOptions(serverOptions: GraphqlMiddlewareServerOptions<any, any>, event: H3Event, operation: GraphqlMiddlewareOperation | null, operationName: string | null, context: GraphqlMiddlewareRequestContext<any> | null): 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 | string, name?: string, documents?: Operations): void;
 /**
  * Handle GraphQL server response.
  */
-export declare function onServerResponse(serverOptions: GraphqlMiddlewareServerOptions<any, any>, event: H3Event, response: FetchResponse<any>, operation: string, operationName: string, context: GraphqlMiddlewareRequestContext<any>): any;
+export declare function onServerResponse(serverOptions: GraphqlMiddlewareServerOptions<any, any>, event: H3Event, response: FetchResponse<any>, operation: string | null, operationName: string | null, context: GraphqlMiddlewareRequestContext<any> | null): any;
 /**
  * Handle GraphQL server errors.
  */
-export declare function onServerError(serverOptions: GraphqlMiddlewareServerOptions<any, any>, event: H3Event, error: FetchError, operation: string, operationName: string, context: GraphqlMiddlewareRequestContext<any>): any;
+export declare function onServerError(serverOptions: GraphqlMiddlewareServerOptions<any, any>, event: H3Event, error: FetchError, operation: string | null, operationName: string | null, context: GraphqlMiddlewareRequestContext<any> | null): any;

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

@@ -1,14 +1,20 @@
 import { createError } from "h3";
 import {
-  CLIENT_CONTEXT_PREFIX,
-  GraphqlMiddlewareOperation
+  CLIENT_CONTEXT_PREFIX
 } from "./../../settings/index.js";
+import { documents } from "#nuxt-graphql-middleware/documents";
+export function isValidMutation(v) {
+  return !!v && Object.hasOwn(documents.mutation, v);
+}
+export function isValidQuery(v) {
+  return !!v && Object.hasOwn(documents.query, v);
+}
 export function queryParamToVariables(query) {
   try {
     if (query.__variables && typeof query.__variables === "string") {
       return JSON.parse(query.__variables);
     }
-  } catch (_e) {
+  } catch {
   }
   return query;
 }
@@ -61,29 +67,6 @@ export function throwError(statusMessage, statusCode = 400) {
     statusMessage
   });
 }
-export function validateRequest(method, operation, name, documents) {
-  if (method !== "POST" && method !== "GET") {
-    throwError("Method not allowed.", 405);
-  }
-  if (operation !== GraphqlMiddlewareOperation.Query && operation !== GraphqlMiddlewareOperation.Mutation) {
-    throwError("Unknown operation.");
-  }
-  if (method === "POST" && operation !== GraphqlMiddlewareOperation.Mutation) {
-    throwError("Queries must be a GET request.");
-  }
-  if (method === "GET" && operation !== GraphqlMiddlewareOperation.Query) {
-    throwError("Mutations must be a POST request.");
-  }
-  if (!name) {
-    throwError("Missing name for operation.");
-  }
-  if (!documents) {
-    throwError("Failed to load GraphQL documents", 500);
-  }
-  if (!documents[operation][name]) {
-    throwError(`Operation "${operation}" with name "${name}" not found.`);
-  }
-}
 export function onServerResponse(serverOptions, event, response, operation, operationName, context) {
   if (serverOptions.onServerResponse) {
     return serverOptions.onServerResponse(

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

@@ -0,0 +1,18 @@
+import type { H3Event } from 'h3';
+import type { GraphqlMiddlewareRequestContext } from '../../types.js';
+import type { GraphqlMiddlewareOperation } from '../../settings/index.js';
+type RequestBody = {
+    query: string;
+    variables?: Record<string, any>;
+    operation?: GraphqlMiddlewareOperation;
+    operationName?: string;
+};
+/**
+ * Perform a raw GraphQL request.
+ *
+ * @param body - The request.
+ * @param context - The client context.
+ * @param event - The H3 event. If not provided, the util will try to get the event using useEvent().
+ */
+export declare function doGraphqlRequest(body: RequestBody, context?: GraphqlMiddlewareRequestContext | null | undefined, providedEvent?: H3Event | null | undefined): Promise<any>;
+export {};

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

@@ -0,0 +1,67 @@
+import { serverOptions } from "#nuxt-graphql-middleware/server-options";
+import { useRuntimeConfig } from "#imports";
+import { useEvent } from "nitropack/runtime";
+import {
+  getEndpoint,
+  getFetchOptions,
+  onServerError,
+  onServerResponse
+} from "../helpers/index.js";
+export async function doGraphqlRequest(body, context = null, providedEvent = null) {
+  const operationName = body.operationName || null;
+  const event = providedEvent ?? useEvent();
+  const runtimeConfig = useRuntimeConfig().graphqlMiddleware;
+  if (serverOptions.doGraphqlRequest) {
+    return serverOptions.doGraphqlRequest({
+      event,
+      operation: body.operation,
+      operationName: body.operationName,
+      operationDocument: body.query,
+      variables: body.variables || {},
+      context: context || {}
+    });
+  }
+  const endpoint = await getEndpoint(
+    runtimeConfig,
+    serverOptions,
+    event,
+    null,
+    operationName,
+    context || null
+  );
+  const fetchOptions = await getFetchOptions(
+    serverOptions,
+    event,
+    null,
+    body.operationName || null,
+    context
+  );
+  return $fetch.raw(endpoint, {
+    // @ts-expect-error Not yet been fixed in nitro.
+    method: "POST",
+    body: {
+      query: body.query,
+      variables: body.variables,
+      operationName: body.operationName
+    },
+    ...fetchOptions
+  }).then((response) => {
+    return onServerResponse(
+      serverOptions,
+      event,
+      response,
+      null,
+      operationName,
+      context
+    );
+  }).catch((error) => {
+    return onServerError(
+      serverOptions,
+      event,
+      error,
+      null,
+      operationName,
+      context
+    );
+  });
+}

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

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

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

@@ -1,4 +1,4 @@
-import { getEndpoint } from "./../../helpers/composables.js";
+import { getEndpoint } from "#nuxt-graphql-middleware/helpers";
 export function performRequest(operation, operationName, method, options) {
   return $fetch(getEndpoint(operation, operationName), {
     ...options,

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

@@ -1,7 +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';
+import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
+import { type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../../helpers/composables.js';
+import type { Mutation } from '#nuxt-graphql-middleware/operation-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>>;
+export declare function useGraphqlMutation<K extends keyof Mutation, R extends GetMutationResult<K>>(...args: GetMutationArgs<K> | [MutationObjectArgs<K>]): Promise<GraphqlResponse<R>>;

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

@@ -1,7 +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';
+import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
+import { type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './../../helpers/composables.js';
+import type { Query } from '#nuxt-graphql-middleware/operation-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>>;
+export declare function useGraphqlQuery<K extends keyof Query, R extends GetQueryResult<K>>(...args: GetQueryArgs<K> | [QueryObjectArgs<K>]): Promise<GraphqlResponse<R>>;

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

@@ -1,3 +1,4 @@
-import type { GraphqlClientContext } from '#graphql-middleware-client-options';
-import { type GraphqlMiddlewareServerOptions } from './../../types.js';
-export declare function defineGraphqlServerOptions<T extends object>(options: GraphqlMiddlewareServerOptions<T, GraphqlClientContext>): GraphqlMiddlewareServerOptions<T, GraphqlClientContext>;
+import type { GraphqlClientContext } from '#nuxt-graphql-middleware/client-options';
+import type { GraphqlMiddlewareResponseUnion } from '#nuxt-graphql-middleware/response';
+import type { GraphqlMiddlewareServerOptions } from './../types.js';
+export declare function defineGraphqlServerOptions<T extends object>(options: GraphqlMiddlewareServerOptions<T, GraphqlMiddlewareResponseUnion, GraphqlClientContext>): GraphqlMiddlewareServerOptions<T, GraphqlMiddlewareResponseUnion, GraphqlClientContext>;

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

@@ -1,17 +1,3 @@
-export declare enum GraphqlMiddlewareTemplate {
-    /**
-     * Contains the TS definitions for all GraphQL queries, mutations and fragments.
-     */
-    OperationTypes = "graphql-operations.d.ts",
-    /**
-     * Signature for the GraphQL composable arguments and return types.
-     */
-    ComposableContext = "nuxt-graphql-middleware/generated-types.d.ts",
-    /**
-     * Exports a single opject containing the compiled queries and mutations.
-     */
-    Documents = "nuxt-graphql-middleware/graphql-documents.mjs"
-}
 export declare enum GraphqlMiddlewareOperation {
     Query = "query",
     Mutation = "mutation"

package/dist/runtime/settings/index.js

@@ -1,9 +1,3 @@
-export var GraphqlMiddlewareTemplate = /* @__PURE__ */ ((GraphqlMiddlewareTemplate2) => {
-  GraphqlMiddlewareTemplate2["OperationTypes"] = "graphql-operations.d.ts";
-  GraphqlMiddlewareTemplate2["ComposableContext"] = "nuxt-graphql-middleware/generated-types.d.ts";
-  GraphqlMiddlewareTemplate2["Documents"] = "nuxt-graphql-middleware/graphql-documents.mjs";
-  return GraphqlMiddlewareTemplate2;
-})(GraphqlMiddlewareTemplate || {});
 export var GraphqlMiddlewareOperation = /* @__PURE__ */ ((GraphqlMiddlewareOperation2) => {
   GraphqlMiddlewareOperation2["Query"] = "query";
   GraphqlMiddlewareOperation2["Mutation"] = "mutation";

package/dist/runtime/types.d.ts

@@ -1,6 +1,12 @@
-import type { FetchOptions, FetchContext } from 'ofetch';
-import type { GraphqlResponse } from '#graphql-middleware-server-options-build';
-import type { GraphqlMiddlewareResponseUnion } from '#nuxt-graphql-middleware/generated-types';
+import type { GraphqlMiddlewareResponseUnion, GraphqlResponse } from '#nuxt-graphql-middleware/response';
+import type { H3Event } from 'h3';
+import type { FetchOptions, FetchResponse, FetchError, FetchContext } from 'ofetch';
+export type OperationResponseError = {
+    operation: string;
+    operationName: string;
+    errors: GraphqlResponseError[];
+    stack?: string;
+};
 export type GraphqlResponseErrorLocation = {
     line: number;
     column: number;
@@ -9,6 +15,7 @@ export type GraphqlResponseError = {
     message: string;
     locations: GraphqlResponseErrorLocation[];
     path: string[];
+    extensions?: Record<string, unknown>;
 };
 export type GraphqlServerResponse<T> = {
     data: T;
@@ -78,3 +85,197 @@ export type GraphqlClientOptions<T extends ContextType = ContextType> = {
      */
     buildClientContext?: () => T;
 };
+export type GraphqlMiddlewareRequestContext<C extends ContextType = ContextType> = {
+    client?: Partial<C>;
+};
+export type GraphqlMiddlewareGraphqlEndpointMethod<C extends ContextType> = (event?: H3Event, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => string | Promise<string> | undefined;
+export type GraphqlMiddlewareServerFetchOptionsMethod<C extends ContextType> = (event?: H3Event, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => FetchOptions | Promise<FetchOptions>;
+export type GraphqlMiddlewareOnServerResponseMethod<ServerReponse, T, C extends ContextType> = (event: H3Event, response: FetchResponse<ServerReponse>, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => T | Promise<T>;
+export type GraphqlMiddlewareOnServerErrorMethod<C extends ContextType> = (event: H3Event, error: FetchError, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => any | Promise<any>;
+export type GraphqlMiddlewareDoRequestMethodContext<C extends ContextType> = {
+    /**
+     * The incoming request event from H3.
+     */
+    event: H3Event;
+    /**
+     * The type of operation.
+     */
+    operation?: 'query' | 'mutation';
+    /**
+     * The name of the operation.
+     */
+    operationName?: string;
+    /**
+     * The operation document (the raw GraphQL query/mutation as a string).
+     */
+    operationDocument: string;
+    /**
+     * Variables for the operation.
+     */
+    variables: Record<string, any>;
+    /**
+     * For file uploads (which are done using FormData), this contains the full
+     * form data with these keys:
+     *
+     * - operations: string
+     *   A JSON string of an object with "query", "variables" and "operationName" properties.
+     *   Example:
+     *   operations='{ "query": "mutation ($id: String!, $file: Upload!) { uploadFile(id: $id, file: $file) { id filename } }", "variables": { "file": null, "id": "1" } }'
+     * - map: string
+     *   A JSON string of an object whose keys are strings starting at '0' and the values being an array with a single string:
+     *   Example:
+     *   map='{ "0": ["variables.file"] }'
+     * - [number]
+     *   For every file there is a FormData entry with a name that matches the key in `map`.
+     *   Example:
+     *   0=[Binary File]
+     */
+    formData?: FormData;
+    context: GraphqlMiddlewareRequestContext<C>;
+};
+export type GraphqlMiddlewareDoRequestMethod<T, C extends ContextType> = (context: GraphqlMiddlewareDoRequestMethodContext<C>) => Promise<T>;
+/**
+ * Configuration options during runtime.
+ */
+export type GraphqlMiddlewareServerOptions<Additions extends object = object, ResponseUnion extends object = object, C extends ContextType = ContextType, CustomResponse = GraphqlServerResponse<ResponseUnion> & Additions> = {
+    /**
+     * Custom callback to return the GraphQL endpoint per request.
+     *
+     * The method is only called if no `doGraphqlRequest` method is implemented.
+     *
+     * @default undefined
+     *
+     * @example
+     * ```ts
+     * function graphqlEndpoint(event, operation, operationName) {
+     *   const language = getLanguageFromRequest(event)
+     *   return `https://api.example.com/${language}/graphql`
+     * }
+     * ```
+     */
+    graphqlEndpoint?: GraphqlMiddlewareGraphqlEndpointMethod<C>;
+    /**
+     * Provide the options for the ofetch request to the GraphQL server.
+     *
+     * The method is only called if no `doGraphqlRequest` method is implemented.
+     *
+     * @default undefined
+     *
+     * @example
+     * ```ts
+     * import { getHeader } from 'h3'
+     *
+     * // Pass the cookie from the client request to the GraphQL request.
+     * function serverFetchOptions(event, operation, operationName) {
+     *   return {
+     *     headers: {
+     *       Cookie: getHeader(event, 'cookie')
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    serverFetchOptions?: GraphqlMiddlewareServerFetchOptionsMethod<C>;
+    /**
+     * Handle the response from the GraphQL server.
+     *
+     * The method is only called if no `doGraphqlRequest` method is implemented.
+     *
+     * You can alter the response, add additional properties to the data, get
+     * and set headers, etc.
+     *
+     * ```ts
+     * import type { H3Event } from 'h3'
+     * import type { FetchResponse } from 'ofetch'
+     *
+     * function onServerResponse(event: H3Event, graphqlResponse: FetchResponse) {
+     *   // Set a static header.
+     *   event.node.res.setHeader('x-nuxt-custom-header', 'A custom header value')
+     *
+     *   // Pass the set-cookie header from the GraphQL response to the client.
+     *   const setCookie = graphqlResponse.headers.get('set-cookie')
+     *   if (setCookie) {
+     *     event.node.res.setHeader('set-cookie', setCookie)
+     *   }
+     *
+     *   // Add additional properties to the response.
+     *   graphqlResponse._data.__customProperty = ['My', 'values']
+     *
+     *   // Return the GraphQL response.
+     *   return graphqlResponse._data
+     * }
+     * ```
+     */
+    onServerResponse?: GraphqlMiddlewareOnServerResponseMethod<GraphqlServerResponse<ResponseUnion>, CustomResponse, C>;
+    /**
+     * Handle a fetch error from the GraphQL request.
+     *
+     * The method is only called if no `doGraphqlRequest` method is implemented.
+     *
+     * Note that errors are only thrown for responses that are not status
+     * 200-299. See https://github.com/unjs/ofetch#%EF%B8%8F-handling-errors for
+     * more information.
+     *
+     * ```ts
+     * import { createError } from 'h3'
+     * import type { H3Event } from 'h3'
+     * import type { FetchError } from 'ofetch'
+     *
+     * function onServerError(
+     *   event: H3Event,
+     *   error: FetchError,
+     *   operation: string,
+     *   operationName: string,
+     * ) {
+     *   // Throw a h3 error.
+     *   throw createError({
+     *     statusCode: 500,
+     *     statusMessage: `Couldn't execute GraphQL ${operation} "${operationName}".`,
+     *     data: error.message
+     *   })
+     * }
+     * ```
+     */
+    onServerError?: GraphqlMiddlewareOnServerErrorMethod<C>;
+    /**
+     * Provide a custom fetch method for requests to the GraphQL server.
+     *
+     * This can be used if onServerError, onServerResponse, serverFetchOptions
+     * and graphqlEndpoint are not enough to meet your requirements.
+     *
+     * When this method is implemented, all other methods are not called.
+     *
+     * The method will be called in the /api/graphql server route and should
+     * perform the GraphQL request and return the response.
+     *
+     * An example use case might be to handle expired tokens.
+     *
+     * * ```ts
+     * async function doGraphqlRequest({
+     *   event,
+     *   operation,
+     *   operationName,
+     *   operationDocument,
+     *   variables,
+     * }) {
+     *   const result = await $fetch.raw('https://example.com/graphql', {
+     *     method: 'POST'
+     *     body: {
+     *       query: operationDocument,
+     *       variables,
+     *       operationName
+     *     },
+     *     headers: {
+     *       'custom-header': 'foobar'
+     *     }
+     *   })
+     *
+     *   return result._data
+     * }
+     * ```
+     */
+    doGraphqlRequest?: GraphqlMiddlewareDoRequestMethod<CustomResponse, C>;
+};
+export type GraphqlMiddlewareRuntimeConfig = {
+    graphqlEndpoint?: string;
+};

package/dist/types.d.mts

@@ -1,7 +1,7 @@
-import type { ModuleHooks } from './module.js'
+import type { NuxtModule } from '@nuxt/schema'
 
-declare module '@nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-}
+import type { default as Module } from './module.js'
 
-export { type GraphqlMiddlewareServerOptions, type ModuleHooks, type ModuleOptions, default } from './module.js'
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type GraphqlMiddlewareServerOptions } from './module.js'

package/dist/types.d.ts

@@ -1,7 +1,7 @@
-import type { ModuleHooks } from './module'
+import type { NuxtModule } from '@nuxt/schema'
 
-declare module '@nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-}
+import type { default as Module } from './module'
 
-export { type GraphqlMiddlewareServerOptions, type ModuleHooks, type ModuleOptions, default } from './module'
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type GraphqlMiddlewareServerOptions } from './module'