nuxt-graphql-middleware 5.0.0 → 5.1.1

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;

package/dist/runtime/helpers/composables.js

@@ -1,4 +1,9 @@
 import { CLIENT_CONTEXT_PREFIX } from "../settings/index.js";
+import { GraphqlMiddlewareCache } from "./ClientCache.js";
+import {
+  clientCacheEnabledAtBuild,
+  importMetaServer
+} from "#nuxt-graphql-middleware/config";
 export function encodeContext(context) {
   return Object.entries(context).reduce(
     (acc, [key, value]) => {
@@ -10,3 +15,25 @@ export function encodeContext(context) {
     {}
   );
 }
+export function sortQueryParams(obj) {
+  const sortedKeys = Object.keys(obj).sort();
+  const sortedObj = {};
+  for (const key of sortedKeys) {
+    sortedObj[key] = obj[key];
+  }
+  return sortedObj;
+}
+export function getOrCreateClientCache(app, config) {
+  if (importMetaServer || !clientCacheEnabledAtBuild) {
+    return;
+  }
+  if (!config.graphqlMiddleware.clientCacheEnabled) {
+    return;
+  }
+  if (!app.$graphqlCache) {
+    app.$graphqlCache = new GraphqlMiddlewareCache(
+      config.graphqlMiddleware.clientCacheMaxSize
+    );
+  }
+  return app.$graphqlCache;
+}

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

@@ -5,7 +5,3 @@
  * items.filter(falsy)
  */
 export declare function falsy<T>(value: T): value is NonNullable<T>;
-/**
- * Get the parameters for the GraphQL middleware query.
- */
-export declare function buildRequestParams(variables?: Record<string, any> | undefined | null): Record<string, any>;

package/dist/runtime/helpers/index.js

@@ -1,16 +1,3 @@
 export function falsy(value) {
   return value !== null && value !== void 0;
 }
-export function buildRequestParams(variables) {
-  if (typeof variables !== "object" || !variables) {
-    return {};
-  }
-  for (const key in variables) {
-    if (typeof variables[key] !== "string") {
-      return {
-        __variables: JSON.stringify(variables)
-      };
-    }
-  }
-  return variables;
-}

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

@@ -0,0 +1,11 @@
+export declare function encodeVariables(variables?: Record<string, any> | null): Record<string, any>;
+/**
+ * Get the variables from query parameters.
+ *
+ * For simple cases with type prefixes:
+ * ?name=Jon&n:age=20&b:isUser=false
+ *
+ * In complex cases, the entire variables are sent as a JSON encoded string:
+ * ?__variables=%7B%22foobar%22:%7B%22path%22:%22%22%7D%7D
+ */
+export declare function decodeVariables(query: Record<string, any>, validKeys?: string[]): any;

package/dist/runtime/helpers/queryEncoding.js

@@ -0,0 +1,89 @@
+import { experimentalQueryParamEncoding } from "#nuxt-graphql-middleware/config";
+import { CLIENT_CONTEXT_PREFIX, OPERATION_HASH_PREFIX } from "../settings/index.js";
+export function encodeVariables(variables) {
+  if (typeof variables !== "object" || !variables) {
+    return {};
+  }
+  if (!experimentalQueryParamEncoding) {
+    for (const key in variables) {
+      if (typeof variables[key] !== "string") {
+        return {
+          __variables: JSON.stringify(variables)
+        };
+      }
+    }
+    return variables;
+  }
+  const result = {};
+  let needsFallback = false;
+  for (const key in variables) {
+    const value = variables[key];
+    const type = typeof value;
+    if (type === "string") {
+      result[key] = value;
+    } else if (type === "number") {
+      result[`n:${key}`] = String(value);
+    } else if (type === "boolean") {
+      result[`b:${key}`] = String(value);
+    } else {
+      needsFallback = true;
+      break;
+    }
+  }
+  if (needsFallback) {
+    return {
+      __variables: JSON.stringify(variables)
+    };
+  }
+  return result;
+}
+function filterValidKeys(validKeys, obj) {
+  return validKeys.reduce((acc, key) => {
+    const value = obj[key];
+    if (value !== void 0 && value !== null) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+}
+export function decodeVariables(query, validKeys) {
+  try {
+    if (query.__variables && typeof query.__variables === "string") {
+      return JSON.parse(query.__variables);
+    }
+  } catch {
+  }
+  if (!experimentalQueryParamEncoding) {
+    if (validKeys) {
+      return filterValidKeys(validKeys, query);
+    }
+    return query;
+  }
+  if (validKeys && validKeys.length === 0) {
+    return {};
+  }
+  const result = {};
+  for (const key in query) {
+    if (key.startsWith(CLIENT_CONTEXT_PREFIX) || key.startsWith(OPERATION_HASH_PREFIX)) {
+      continue;
+    } else if (key.startsWith("n:")) {
+      const actualKey = key.substring(2);
+      if (validKeys && !validKeys.includes(actualKey)) {
+        continue;
+      }
+      result[actualKey] = Number(query[key]);
+    } else if (key.startsWith("b:")) {
+      const actualKey = key.substring(2);
+      if (validKeys && !validKeys.includes(actualKey)) {
+        continue;
+      }
+      result[actualKey] = query[key] === "true";
+    } else if (key !== "__variables") {
+      if (validKeys && !validKeys.includes(key)) {
+        continue;
+      }
+      result[key] = query[key];
+    }
+  }
+  return result;
+}

package/dist/runtime/plugins/devMode.js

@@ -1,6 +1,7 @@
 import { defineNuxtPlugin, useState } from "#imports";
 import { createApp } from "vue";
 import DevModeOverlay from "../components/DevModeOverlay.vue";
+import { importMetaClient } from "#nuxt-graphql-middleware/config";
 export default defineNuxtPlugin({
   name: "nuxt-graphql-middleware:dev-mode",
   setup(nuxtApp) {
@@ -11,7 +12,7 @@ export default defineNuxtPlugin({
     nuxtApp.hook("nuxt-graphql-middleware:errors", (value) => {
       errors.value.push(value);
     });
-    if (import.meta.client) {
+    if (importMetaClient) {
       nuxtApp.hook("app:mounted", () => {
         const container = document.createElement("div");
         document.body.appendChild(container);

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

@@ -1,13 +1,10 @@
 import { defineEventHandler, getQuery, getRouterParam } from "h3";
-import {
-  queryParamToVariables,
-  extractRequestContext,
-  isValidQuery,
-  throwError
-} from "./../helpers/index.js";
+import { 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";
+import { decodeVariables } from "../../helpers/queryEncoding.js";
+import { operationVariables } from "#nuxt-graphql-middleware/operation-variables";
 export default defineEventHandler(async (event) => {
   const operationName = getRouterParam(event, "name");
   if (!isValidQuery(operationName)) {
@@ -16,7 +13,8 @@ export default defineEventHandler(async (event) => {
   const operationDocument = documents.query[operationName];
   const queryParams = getQuery(event);
   const context = extractRequestContext(queryParams);
-  const variables = queryParamToVariables(queryParams);
+  const validVariableKeys = operationVariables[operationName];
+  const variables = decodeVariables(queryParams, validVariableKeys);
   return doGraphqlRequest(
     {
       query: operationDocument,

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

@@ -1,7 +1,7 @@
 import {
   encodeContext
 } from "./../../helpers/composables.js";
-import { buildRequestParams } from "./../../helpers/index.js";
+import { encodeVariables } from "./../../helpers/queryEncoding.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] : [
@@ -14,7 +14,7 @@ export function useGraphqlQuery(...args) {
     ...fetchOptions,
     params: {
       ...fetchOptions.params || {},
-      ...buildRequestParams(variables),
+      ...encodeVariables(variables),
       ...encodeContext(clientContext)
     }
   });

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

@@ -3,3 +3,4 @@ export declare enum GraphqlMiddlewareOperation {
     Mutation = "mutation"
 }
 export declare const CLIENT_CONTEXT_PREFIX = "__gqlc_";
+export declare const OPERATION_HASH_PREFIX = "__gqlh";

package/dist/runtime/settings/index.js

@@ -4,3 +4,4 @@ export var GraphqlMiddlewareOperation = /* @__PURE__ */ ((GraphqlMiddlewareOpera
   return GraphqlMiddlewareOperation2;
 })(GraphqlMiddlewareOperation || {});
 export const CLIENT_CONTEXT_PREFIX = "__gqlc_";
+export const OPERATION_HASH_PREFIX = "__gqlh";

package/dist/shared/{nuxt-graphql-middleware.cXfDI4U3.d.mts → nuxt-graphql-middleware.-BeiPV4H.d.mts}

@@ -169,15 +169,64 @@ interface ModuleOptions {
     };
     /**
      * Enable Nuxt DevTools integration.
+     *
+     * @default true
      */
     devtools?: boolean;
     /**
      * Client caching configuration.
      */
     clientCache?: {
+        /**
+         * Whether client caching should be enabled.
+         *
+         * Note that if you set this to false during build, the cache will not be
+         * available at all. If you intend to enable/disable it using app config at
+         * runtime, it *must* be enabled at build!
+         *
+         * @default false
+         */
         enabled?: boolean;
+        /**
+         * The maximum number of cache entries.
+         *
+         * @default 100
+         */
         maxSize?: number;
     };
+    /**
+     * Experimental features.
+     */
+    experimental?: {
+        /**
+         * Enables improved encoding for GraphQL query param encoding.
+         *
+         * If enabled, query variables that are non-strings such as numbers or
+         * booleans are encoded as strings, with a prefix in their name to indicate
+         * the type.
+         *
+         * For example, given this object definining query variables:
+         *
+         * ```
+         * {
+         *   name: 'John',
+         *   age: 35,
+         *   isUser: false
+         * }
+         * ```
+         *
+         * This would be encoded as:
+         *
+         * ```
+         * name=John&n:age=35&b:isUser=false
+         * ```
+         *
+         * This only works for flat primitive values. Nested objects or arrays are
+         * still encoded using the __variables fallback where all variables are
+         * JSON encoded.
+         */
+        improvedQueryParamEncoding?: boolean;
+    };
 }
 
 declare const defaultOptions: ModuleOptions;