nuxt-graphql-middleware 5.0.0 → 5.1.0

package/dist/module.mjs

@@ -15,11 +15,12 @@ import { defu } from 'defu';
 import micromatch from 'micromatch';
 import { ConfirmPrompt } from '@clack/core';
 import isUnicodeSupported from 'is-unicode-supported';
+import { hash } from 'ohash';
 import { existsSync as existsSync$1 } from 'fs';
 import { onDevToolsInitialized, extendServerRpc } from '@nuxt/devtools-kit';
 
 const name = "nuxt-graphql-middleware";
-const version = "5.0.0";
+const version = "5.1.0";
 
 const logger = useLogger("nuxt-graphql-middleware");
 const defaultOptions = {
@@ -32,7 +33,14 @@ const defaultOptions = {
   documents: [],
   devtools: true,
   errorOverlay: true,
-  graphqlConfigFilePath: "./graphql.config.ts"
+  graphqlConfigFilePath: "./graphql.config.ts",
+  experimental: {
+    improvedQueryParamEncoding: false
+  },
+  clientCache: {
+    enabled: false,
+    maxSize: 100
+  }
 };
 function validateOptions(options) {
   if (!options.graphqlEndpoint) {
@@ -816,6 +824,7 @@ class ModuleHelper {
     if (!mergedOptions.autoImportPatterns) {
       mergedOptions.autoImportPatterns = [
         "~~/**/*.{gql,graphql}",
+        "~/**/*.{gql,graphql}",
         "!node_modules"
       ];
     }
@@ -1070,7 +1079,7 @@ const ClientOptions = defineStaticTemplate(
 export { clientOptions }
 `;
     }
-    return `export const clientOptions = {}`;
+    return `export const clientOptions = undefined`;
   },
   (helper) => {
     if (helper.paths.clientOptions) {
@@ -1080,19 +1089,41 @@ export { clientOptions }
       return `import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
 import clientOptionsImport from '${pathRelative}'
 
-declare export const clientOptions: GraphqlClientOptions
+declare export const clientOptions: GraphqlClientOptions|undefined
 export type GraphqlClientContext = typeof clientOptionsImport extends GraphqlClientOptions<infer R> ? R : {}
 `;
     }
     return `
 import type { GraphqlClientOptions } from '${helper.paths.runtimeTypes}'
 
-declare export const clientOptions: GraphqlClientOptions
+declare export const clientOptions: GraphqlClientOptions|undefined
 export type GraphqlClientContext = {}
 `;
   }
 );
 
+const Config = defineStaticTemplate(
+  { path: "nuxt-graphql-middleware/config" },
+  (helper) => {
+    const experimentalQueryParamEncoding = !!helper.options.experimental.improvedQueryParamEncoding;
+    const clientCacheEnabledAtBuild = !!helper.options.clientCache.enabled;
+    return `
+export const experimentalQueryParamEncoding = ${JSON.stringify(experimentalQueryParamEncoding)}
+export const clientCacheEnabledAtBuild = ${JSON.stringify(clientCacheEnabledAtBuild)}
+export const importMetaServer = import.meta.server
+export const importMetaClient = import.meta.client
+`;
+  },
+  () => {
+    return `
+declare export const experimentalQueryParamEncoding: boolean
+declare export const clientCacheEnabledAtBuild: boolean
+declare export const importMetaServer: boolean
+declare export const importMetaClient: boolean
+`;
+  }
+);
+
 const Documents = defineGeneratorTemplate(
   { path: "nuxt-graphql-middleware/documents", virtual: true },
   (output, helper) => {
@@ -1181,6 +1212,43 @@ export function getEndpoint(operation: string, operationName: string): string`;
   }
 );
 
+const HookDocuments = defineGeneratorTemplate(
+  {
+    path: "nuxt-graphql-middleware/hook-documents.graphql",
+    virtual: false,
+    isFullPath: true
+  },
+  (_output, _helper, collector) => {
+    return collector.getHookDocuments().map((v) => {
+      return `
+# ${v.identifier}
+${v.source}
+`;
+    }).join("\n\n");
+  },
+  null
+);
+
+const HookFiles = defineGeneratorTemplate(
+  {
+    path: "nuxt-graphql-middleware/hook-files",
+    virtual: false
+  },
+  (_output, helper, collector) => {
+    const configPath = helper.resolvers.root.resolve(
+      (helper.options.graphqlConfigFilePath || "").replace(
+        "/graphql.config.ts",
+        ""
+      )
+    );
+    const files = collector.getHookFiles().map((filePath) => {
+      return "./" + relative(configPath, filePath);
+    });
+    return `export const hookFiles = ${JSON.stringify(files, null, 2)}`;
+  },
+  null
+);
+
 const NitroTypes = defineGeneratorTemplate(
   { path: "nuxt-graphql-middleware/nitro" },
   null,
@@ -1211,6 +1279,46 @@ ${endpoints.sort().join("\n")}
   }
 );
 
+const OperationHashes = defineGeneratorTemplate(
+  { path: "nuxt-graphql-middleware/operation-hashes", virtual: true },
+  (output, helper) => {
+    if (helper.isDev) {
+      return `export const operationHashes = {}`;
+    }
+    const fragmentHashMap = {};
+    const generatedCode = output.getGeneratedCode();
+    generatedCode.forEach((code) => {
+      if (code.type === "fragment") {
+        const fragmentHash = hash(code.source);
+        if (code.graphqlName) {
+          fragmentHashMap[code.graphqlName] = fragmentHash;
+        }
+      }
+    });
+    const lines = [];
+    generatedCode.forEach((code) => {
+      if (code.type === "operation" && code.graphqlName && code.source) {
+        const source = code.source;
+        const fragments = code.getGraphQLFragmentDependencies().map((fragmentName) => {
+          return fragmentHashMap[fragmentName];
+        }).join("");
+        const sourceHash = hash(source + fragments);
+        lines.push(`"${code.graphqlName}": "${sourceHash.substring(0, 10)}"`);
+      }
+    });
+    return `export const operationHashes = {
+  ${lines.sort().join(",\n  ")}
+}`;
+  },
+  () => {
+    return `
+declare module '#nuxt-graphql-middleware/operation-hashes' {
+  export const operationHashes: Record<string, string>;
+}
+`;
+  }
+);
+
 const OperationTypesAll = defineGeneratorTemplate(
   { path: "nuxt-graphql-middleware/operation-types" },
   () => `export {}`,
@@ -1233,6 +1341,27 @@ const Operations = defineGeneratorTemplate(
   }
 );
 
+const OperationVariables = defineGeneratorTemplate(
+  { path: "nuxt-graphql-middleware/operation-variables" },
+  (output) => {
+    const operations = output.getCollectedOperations().reduce((acc, collectedOperation) => {
+      const node = collectedOperation.node;
+      const operationName = collectedOperation.graphqlName;
+      const variables = (node.variableDefinitions || []).map(
+        (v) => v.variable.name.value
+      );
+      acc[operationName] = variables;
+      return acc;
+    }, {});
+    return `export const operationVariables = ${JSON.stringify(operations, null, 2)}`;
+  },
+  () => {
+    return `
+declare export const operationVariables: Record<string, string[]>
+`;
+  }
+);
+
 const Response = defineGeneratorTemplate(
   { path: "nuxt-graphql-middleware/response" },
   null,
@@ -1313,56 +1442,22 @@ export const operationSources = {
   }
 );
 
-const HookDocuments = defineGeneratorTemplate(
-  {
-    path: "nuxt-graphql-middleware/hook-documents.graphql",
-    virtual: false,
-    isFullPath: true
-  },
-  (_output, _helper, collector) => {
-    return collector.getHookDocuments().map((v) => {
-      return `
-# ${v.identifier}
-${v.source}
-`;
-    }).join("\n\n");
-  },
-  null
-);
-
-const HookFiles = defineGeneratorTemplate(
-  {
-    path: "nuxt-graphql-middleware/hook-files",
-    virtual: false
-  },
-  (_output, helper, collector) => {
-    const configPath = helper.resolvers.root.resolve(
-      (helper.options.graphqlConfigFilePath || "").replace(
-        "/graphql.config.ts",
-        ""
-      )
-    );
-    const files = collector.getHookFiles().map((filePath) => {
-      return "./" + relative(configPath, filePath);
-    });
-    return `export const hookFiles = ${JSON.stringify(files, null, 2)}`;
-  },
-  null
-);
-
 const TEMPLATES = [
   ClientOptions,
+  Config,
   Documents,
   GraphqlConfig,
   Helpers,
+  HookDocuments,
+  HookFiles,
   NitroTypes,
+  OperationHashes,
   OperationTypesAll,
   Operations,
+  OperationVariables,
   Response,
   ServerOptions,
-  Sources,
-  HookDocuments,
-  HookFiles
+  Sources
 ];
 
 const DEVTOOLS_UI_ROUTE = "/__nuxt-graphql-middleware";
@@ -1612,7 +1707,7 @@ const module = defineNuxtModule({
     configKey: "graphqlMiddleware",
     version,
     compatibility: {
-      nuxt: ">=3.15.0"
+      nuxt: ">=3.17.0"
     }
   },
   defaults: defaultOptions,

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

@@ -1,8 +1,36 @@
 import type { FetchOptions } from 'ofetch';
-import { GraphqlMiddlewareCache } from '../helpers/ClientCache.js';
+import type { GraphqlMiddlewareCache } from '../helpers/ClientCache.js';
 import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
 import type { RequestCacheOptions } from './../types.js';
-export declare function performRequest<T>(operation: string, operationName: string, method: 'get' | 'post', options: FetchOptions, cacheOptions?: RequestCacheOptions): Promise<GraphqlResponse<T>>;
+export declare function performRequest<T>(
+/**
+ * The operation type.
+ */
+operation: 'query' | 'mutation', 
+/**
+ * The name of the operation.
+ */
+operationName: string, 
+/**
+ * The operation variables.
+ */
+variablesOrBody: Record<string, any>, 
+/**
+ * Fetch options set on the composable.
+ */
+overrideFetchOptions: FetchOptions, 
+/**
+ * The global client options determined in the composable.
+ */
+globalClientContext: Record<string, any>, 
+/**
+ * Client options overrides set on the composable.
+ */
+overrideClientContext: Record<string, any>, 
+/**
+ * The cache options set on the composable.
+ */
+cacheOptions: RequestCacheOptions): Promise<GraphqlResponse<T>>;
 declare module '#app' {
     interface NuxtApp {
         $graphqlCache?: GraphqlMiddlewareCache;

package/dist/runtime/composables/nuxtApp.js

@@ -1,26 +1,57 @@
 import { useGraphqlState } from "./useGraphqlState.js";
 import { hash } from "ohash";
-import { GraphqlMiddlewareCache } from "../helpers/ClientCache.js";
 import { getEndpoint } from "#nuxt-graphql-middleware/helpers";
 import { useNuxtApp, useAppConfig } from "#imports";
-export function performRequest(operation, operationName, method, options, cacheOptions) {
+import { operationHashes } from "#nuxt-graphql-middleware/operation-hashes";
+import {
+  clientCacheEnabledAtBuild,
+  importMetaClient
+} from "#nuxt-graphql-middleware/config";
+import { encodeVariables } from "../helpers/queryEncoding.js";
+import {
+  encodeContext,
+  getOrCreateClientCache,
+  sortQueryParams
+} from "../helpers/composables.js";
+import { OPERATION_HASH_PREFIX } from "../settings/index.js";
+export function performRequest(operation, operationName, variablesOrBody, overrideFetchOptions, globalClientContext, overrideClientContext, cacheOptions) {
   const state = useGraphqlState();
   const app = useNuxtApp();
+  const config = useAppConfig();
+  const method = operation === "query" ? "get" : "post";
+  const isQuery = operation === "query";
   if (!state) {
     console.error(
       `A GraphQL composable for ${operation} "${operationName}" was called before the "nuxt-graphql-middleware-provide-state" plugin could provide the state, which might lead to unexpected behaviour. Make sure that custom plugins that perform GraphQL requests are executed after "nuxt-graphql-middleware-provide-state" by setting it as a dependency via "dependsOn".`
     );
   }
-  const key = `${operation}:${operationName}:${hash(options.params)}`;
-  if (cacheOptions) {
-    const config = useAppConfig();
-    if (import.meta.client && cacheOptions.client && config.graphqlMiddleware.clientCacheEnabled) {
-      if (!app.$graphqlCache) {
-        app.$graphqlCache = new GraphqlMiddlewareCache(
-          config.graphqlMiddleware.clientCacheMaxSize
-        );
-      }
-      const cached = app.$graphqlCache.get(key);
+  const clientContext = Object.assign(
+    {},
+    globalClientContext,
+    overrideClientContext
+  );
+  const fetchOptions = Object.assign(
+    {},
+    state?.fetchOptions,
+    overrideFetchOptions
+  );
+  const paramsRaw = Object.assign(
+    importMetaClient ? {
+      // The unique operation hash that changes whenever any operation source or
+      // fragment changes.
+      [OPERATION_HASH_PREFIX]: operationHashes[operationName]
+    } : {},
+    encodeContext(clientContext),
+    fetchOptions.params,
+    fetchOptions.query,
+    isQuery ? encodeVariables(variablesOrBody) : null
+  );
+  const params = importMetaClient && isQuery ? sortQueryParams(paramsRaw) : paramsRaw;
+  const cacheKey = importMetaClient && clientCacheEnabledAtBuild && isQuery && cacheOptions?.client && config.graphqlMiddleware.clientCacheEnabled ? `${operation}:${operationName}:${hash(params)}` : void 0;
+  if (importMetaClient && cacheKey) {
+    const cache = getOrCreateClientCache(app, config);
+    if (cache) {
+      const cached = cache.get(cacheKey);
       if (cached) {
         if (import.meta.dev) {
           cached.then((response) => {
@@ -40,11 +71,23 @@ export function performRequest(operation, operationName, method, options, cacheO
   }
   const promise = $fetch(
     getEndpoint(operation, operationName),
-    {
-      ...state && state.fetchOptions ? state.fetchOptions : {},
-      ...options,
-      method
-    }
+    Object.assign(
+      {},
+      // Use the merged fetch options.
+      fetchOptions,
+      // Remove params and query from the fetch options.
+      {
+        params: void 0,
+        query: void 0
+      },
+      // Set the previously merged params. That way we only ever pass "params"
+      // as the query params.
+      {
+        params,
+        method,
+        body: operation === "mutation" ? variablesOrBody : void 0
+      }
+    )
   ).then((v) => {
     if (import.meta.dev && v.errors?.length) {
       app.callHook("nuxt-graphql-middleware:errors", {
@@ -54,14 +97,13 @@ export function performRequest(operation, operationName, method, options, cacheO
         stack: Error().stack
       });
     }
-    return {
-      ...v,
-      data: v.data,
-      errors: v.errors || []
-    };
+    return Object.assign({}, v, {
+      data: v?.data,
+      errors: v?.errors || []
+    });
   });
-  if (import.meta.client && cacheOptions?.client && app.$graphqlCache) {
-    app.$graphqlCache.set(key, promise);
+  if (importMetaClient && cacheKey && app.$graphqlCache && clientCacheEnabledAtBuild) {
+    app.$graphqlCache.set(cacheKey, promise);
   }
   return promise;
 }

package/dist/runtime/composables/useAsyncGraphqlQuery.js

@@ -1,57 +1,60 @@
 import {
-  encodeContext
+  getOrCreateClientCache
 } from "./../helpers/composables.js";
 import { isRef, unref } from "vue";
-import { buildRequestParams } from "./../helpers/index.js";
 import { performRequest } from "./nuxtApp.js";
 import {
   clientOptions
 } from "#nuxt-graphql-middleware/client-options";
-import { useAsyncData, useAppConfig, useNuxtApp } from "#imports";
+import { useAsyncData, useAppConfig, useNuxtApp, computed } from "#imports";
 import { hash } from "ohash";
+import { importMetaClient } from "#nuxt-graphql-middleware/config";
 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 asyncDataKey = computed(() => {
+    const vars = isRef(variables) ? variables.value : variables;
+    return `useAsyncGraphqlQuery:${name}:${hash(vars)}`;
+  });
   const config = useAppConfig();
   const app = useNuxtApp();
-  if (import.meta.client) {
+  if (importMetaClient) {
     if (variables && isRef(variables)) {
       if (!asyncDataOptions.watch) {
         asyncDataOptions.watch = [];
       }
       asyncDataOptions.watch.push(variables);
     }
+    if (asyncDataOptions.graphqlCaching?.client && app.isHydrating) {
+      const cache = getOrCreateClientCache(app, config);
+      if (cache) {
+        const key = asyncDataKey.value;
+        const payload = app.payload.data[asyncDataKey.value];
+        if (payload) {
+          cache.set(key, payload);
+        }
+      }
+    }
     if (asyncDataOptions.graphqlCaching?.client && !asyncDataOptions.getCachedData) {
-      asyncDataOptions.getCachedData = function(key2) {
-        if (!app.isHydrating && !config.graphqlMiddleware.clientCacheEnabled) {
-          return;
+      asyncDataOptions.getCachedData = function(key, app2, ctx) {
+        if (ctx.cause === "initial") {
+          return app2.payload.data[key] ?? app2.$graphqlCache?.get(key);
         }
-        return app.payload.data[key2];
       };
     }
   }
   const result = useAsyncData(
-    key,
+    asyncDataKey,
     () => {
-      const globalClientContext = clientOptions.buildClientContext ? clientOptions.buildClientContext() : {};
+      const globalClientContext = clientOptions && clientOptions.buildClientContext ? clientOptions.buildClientContext() : {};
       return performRequest(
         "query",
         name,
-        "get",
-        {
-          ...fetchOptions,
-          params: {
-            ...fetchOptions?.params || {},
-            ...buildRequestParams(unref(variables)),
-            ...encodeContext({
-              ...globalClientContext,
-              ...asyncDataOptions.clientContext || {}
-            })
-          }
-        },
-        asyncDataOptions.graphqlCaching
+        unref(variables) || {},
+        asyncDataOptions.fetchOptions || {},
+        globalClientContext,
+        asyncDataOptions.clientContext || {},
+        asyncDataOptions.graphqlCaching || {}
       );
     },
     asyncDataOptions

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

@@ -1,4 +1,4 @@
-import { type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../helpers/composables.js';
+import type { GetMutationArgs, MutationObjectArgs, GetMutationResult } from './../helpers/composables.js';
 import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
 import type { Mutation } from '#nuxt-graphql-middleware/operation-types';
 /**

package/dist/runtime/composables/useGraphqlMutation.js

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

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

@@ -1,4 +1,4 @@
-import { type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './../helpers/composables.js';
+import type { GetQueryArgs, QueryObjectArgs, GetQueryResult } from './../helpers/composables.js';
 import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
 import type { Query } from '#nuxt-graphql-middleware/operation-types';
 /**

package/dist/runtime/composables/useGraphqlQuery.js

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

package/dist/runtime/composables/useGraphqlUploadMutation.js

@@ -49,7 +49,7 @@ export function useGraphqlUploadMutation(...args) {
   }
   const state = useGraphqlState();
   const formData = createFormData(variables);
-  const globalClientContext = clientOptions.buildClientContext ? clientOptions.buildClientContext() : {};
+  const globalClientContext = clientOptions && clientOptions.buildClientContext ? clientOptions.buildClientContext() : {};
   const clientContext = encodeContext({
     ...globalClientContext,
     ...overrideClientContext

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

@@ -12,4 +12,5 @@ export declare class GraphqlMiddlewareCache {
     set(key: string, value: unknown): void;
     get<T>(key: string): T | undefined;
     purge(): void;
+    remove(key: string): boolean;
 }

package/dist/runtime/helpers/ClientCache.js

@@ -36,5 +36,17 @@ export class GraphqlMiddlewareCache {
   }
   purge() {
     this.cache = {};
+    this.keys = [];
+  }
+  remove(key) {
+    if (Object.prototype.hasOwnProperty.call(this.cache, key)) {
+      delete this.cache[key];
+      const index = this.keys.indexOf(key);
+      if (index > -1) {
+        this.keys.splice(index, 1);
+      }
+      return true;
+    }
+    return false;
   }
 }

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

@@ -2,6 +2,9 @@ import type { FetchOptions } from 'ofetch';
 import type { RequestCacheOptions } from './../types.js';
 import type { GraphqlClientContext } from '#nuxt-graphql-middleware/client-options';
 import type { Query, Mutation } from '#nuxt-graphql-middleware/operation-types';
+import type { NuxtApp } from '#app';
+import type { AppConfig } from 'nuxt/schema';
+import { GraphqlMiddlewareCache } from './ClientCache.js';
 export type GraphqlComposableOptions = {
     fetchOptions?: FetchOptions;
     graphqlCaching?: RequestCacheOptions;
@@ -38,3 +41,8 @@ export type MutationObjectArgs<K extends keyof Mutation, M extends Mutation[K] =
 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>;
+/**
+ * Sort an object defining query params alphabetically.
+ */
+export declare function sortQueryParams(obj: Record<string, string>): Record<string, string>;
+export declare function getOrCreateClientCache(app: NuxtApp, config: AppConfig): GraphqlMiddlewareCache | undefined;