@envelop/response-cache 3.0.0-alpha-4ba70ab.0 → 3.0.0-alpha-868cc42.0

package/README.md

@@ -8,6 +8,18 @@
 
 [Check out the GraphQL Response Cache Guide for more information](https://envelop.dev/docs/guides/adding-a-graphql-response-cache)
 
+> Watch [Episode #34 of `graphql.wtf`](https://graphql.wtf/episodes/34-response-cache-plugin-with-envelop) for a quick introduction to using Response Cache plugin with Envelop:
+
+<iframe
+  width="100%"
+  height="400"
+  src="https://www.youtube.com/embed/1EBphPltkA4"
+  title="YouTube video player"
+  frameBorder="0"
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+  allowFullScreen
+></iframe>
+
 ## Getting Started
 
 ```bash

package/index.js

@@ -124,7 +124,7 @@ const hashSHA256 = async (text) => {
     if (nodeCrypto) {
         return nodeCrypto.then(crypto => crypto.createHash('sha256').update(text).digest('hex'));
     }
-    else if (webCrypto) {
+    if (webCrypto) {
         let buf;
         if (typeof TextEncoder !== 'undefined') {
             buf = new TextEncoder().encode(text);
@@ -154,7 +154,6 @@ const hashSHA256 = async (text) => {
 };
 
 const contextSymbol = Symbol('responseCache');
-const rawDocumentStringSymbol = Symbol('rawDocumentString');
 /**
  * Default function used for building the response cache key.
  * It is exported here for advanced use-cases. E.g. if you want to short circuit and serve responses from the cache on a global level in order to completely by-pass the GraphQL flow.
@@ -184,31 +183,40 @@ const defaultShouldCacheResult = (params) => {
     }
     return true;
 };
-const defaultGetDocumentStringFromContext = context => context[rawDocumentStringSymbol];
-function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session = () => null, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = defaultBuildResponseCacheKey, getDocumentStringFromContext = defaultGetDocumentStringFromContext, shouldCacheResult = defaultShouldCacheResult, 
+const documentStringByDocument = new WeakMap();
+function defaultGetDocumentString(executionArgs) {
+    let documentString = documentStringByDocument.get(executionArgs.document);
+    if (!documentString) {
+        documentString = graphql.print(executionArgs.document);
+        documentStringByDocument.set(executionArgs.document, documentString);
+    }
+    return documentString;
+}
+function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session = () => null, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = defaultBuildResponseCacheKey, getDocumentString = defaultGetDocumentString, shouldCacheResult = defaultShouldCacheResult, 
 // eslint-disable-next-line dot-notation
 includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_ENV'] === 'development' : false, } = {}) {
+    const appliedTransform = Symbol('responseCache.appliedTransform');
     const ignoredTypesMap = new Set(ignoredTypes);
-    const schemaCache = new WeakMap();
     // never cache Introspections
     ttlPerSchemaCoordinate = { 'Query.__schema': 0, ...ttlPerSchemaCoordinate };
     return {
-        onSchemaChange(ctx) {
-            let schema = schemaCache.get(ctx.schema);
-            if (schema == null) {
-                schema = applyResponseCacheLogic(ctx.schema, idFields);
-                schemaCache.set(ctx.schema, schema);
+        onSchemaChange({ schema, replaceSchema }) {
+            var _a;
+            // @ts-expect-error See https://github.com/graphql/graphql-js/pull/3511 - remove this comments once merged
+            if (((_a = schema.extensions) === null || _a === void 0 ? void 0 : _a[appliedTransform]) === true) {
+                return;
             }
-            ctx.replaceSchema(schema);
+            const patchedSchema = applyResponseCacheLogic(schema, idFields);
+            patchedSchema.extensions = {
+                ...patchedSchema.extensions,
+                [appliedTransform]: true,
+            };
+            replaceSchema(patchedSchema);
         },
-        onParse(parseCtx) {
-            return function onParseEnd(ctx) {
-                if (ctx.result && 'kind' in ctx.result) {
-                    const source = parseCtx.params.source;
-                    const rawDocumentString = typeof source === 'string' ? source : source.body;
-                    ctx.extendContext({
-                        [rawDocumentStringSymbol]: rawDocumentString,
-                    });
+        onParse({ params: { source } }) {
+            return function onParseEnd({ result }) {
+                if (result != null && !(result instanceof Error)) {
+                    documentStringByDocument.set(result, source.toString());
                 }
             };
         },
@@ -253,102 +261,91 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                     },
                 };
             }
-            else {
-                const documentString = getDocumentStringFromContext(ctx.args.contextValue);
-                if (documentString != null) {
-                    const operationId = await buildResponseCacheKey({
-                        documentString,
-                        variableValues: ctx.args.variableValues,
-                        operationName: ctx.args.operationName,
-                        sessionId: session(ctx.args.contextValue),
-                    });
-                    if (((_a = enabled === null || enabled === void 0 ? void 0 : enabled(ctx.args.contextValue)) !== null && _a !== void 0 ? _a : true) === true) {
-                        const cachedResponse = await cache.get(operationId);
-                        if (cachedResponse != null) {
-                            if (includeExtensionMetadata) {
-                                ctx.setResultAndStopExecution({
-                                    ...cachedResponse,
-                                    extensions: {
-                                        responseCache: {
-                                            hit: true,
-                                        },
-                                    },
-                                });
-                            }
-                            else {
-                                ctx.setResultAndStopExecution(cachedResponse);
+            const operationId = await buildResponseCacheKey({
+                documentString: getDocumentString(ctx.args),
+                variableValues: ctx.args.variableValues,
+                operationName: ctx.args.operationName,
+                sessionId: session(ctx.args.contextValue),
+            });
+            if (((_a = enabled === null || enabled === void 0 ? void 0 : enabled(ctx.args.contextValue)) !== null && _a !== void 0 ? _a : true) === true) {
+                const cachedResponse = await cache.get(operationId);
+                if (cachedResponse != null) {
+                    if (includeExtensionMetadata) {
+                        ctx.setResultAndStopExecution({
+                            ...cachedResponse,
+                            extensions: {
+                                responseCache: {
+                                    hit: true,
+                                },
+                            },
+                        });
+                    }
+                    else {
+                        ctx.setResultAndStopExecution(cachedResponse);
+                    }
+                    return;
+                }
+            }
+            if (ttlPerSchemaCoordinate) {
+                const typeInfo = new graphql.TypeInfo(ctx.args.schema);
+                graphql.visit(ctx.args.document, graphql.visitWithTypeInfo(typeInfo, {
+                    Field(fieldNode) {
+                        const parentType = typeInfo.getParentType();
+                        if (parentType) {
+                            const schemaCoordinate = `${parentType.name}.${fieldNode.name.value}`;
+                            const maybeTtl = ttlPerSchemaCoordinate[schemaCoordinate];
+                            if (maybeTtl !== undefined) {
+                                context.currentTtl = calculateTtl(maybeTtl, context.currentTtl);
                             }
-                            return;
                         }
+                    },
+                }));
+            }
+            return {
+                onExecuteDone({ result, setResult }) {
+                    var _a;
+                    if (core.isAsyncIterable(result)) {
+                        // eslint-disable-next-line no-console
+                        console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
+                        return;
                     }
-                    if (ttlPerSchemaCoordinate) {
-                        const typeInfo = new graphql.TypeInfo(ctx.args.schema);
-                        graphql.visit(ctx.args.document, graphql.visitWithTypeInfo(typeInfo, {
-                            Field(fieldNode) {
-                                const parentType = typeInfo.getParentType();
-                                if (parentType) {
-                                    const schemaCoordinate = `${parentType.name}.${fieldNode.name.value}`;
-                                    const maybeTtl = ttlPerSchemaCoordinate[schemaCoordinate];
-                                    if (maybeTtl !== undefined) {
-                                        context.currentTtl = calculateTtl(maybeTtl, context.currentTtl);
-                                    }
-                                }
-                            },
-                        }));
+                    if (context.skip) {
+                        return;
                     }
-                    return {
-                        onExecuteDone({ result, setResult }) {
-                            var _a;
-                            if (core.isAsyncIterable(result)) {
-                                // eslint-disable-next-line no-console
-                                console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
-                                return;
-                            }
-                            if (context.skip) {
-                                return;
-                            }
-                            if (!shouldCacheResult({ result })) {
-                                return;
-                            }
-                            // we only use the global ttl if no currentTtl has been determined.
-                            const finalTtl = (_a = context.currentTtl) !== null && _a !== void 0 ? _a : globalTtl;
-                            if (finalTtl === 0) {
-                                if (includeExtensionMetadata) {
-                                    setResult({
-                                        ...result,
-                                        extensions: {
-                                            responseCache: {
-                                                hit: false,
-                                                didCache: false,
-                                            },
-                                        },
-                                    });
-                                }
-                                return;
-                            }
-                            cache.set(operationId, result, identifier.values(), finalTtl);
-                            if (includeExtensionMetadata) {
-                                setResult({
-                                    ...result,
-                                    extensions: {
-                                        responseCache: {
-                                            hit: false,
-                                            didCache: true,
-                                            ttl: finalTtl,
-                                        },
+                    if (!shouldCacheResult({ result })) {
+                        return;
+                    }
+                    // we only use the global ttl if no currentTtl has been determined.
+                    const finalTtl = (_a = context.currentTtl) !== null && _a !== void 0 ? _a : globalTtl;
+                    if (finalTtl === 0) {
+                        if (includeExtensionMetadata) {
+                            setResult({
+                                ...result,
+                                extensions: {
+                                    responseCache: {
+                                        hit: false,
+                                        didCache: false,
                                     },
-                                });
-                            }
-                        },
-                    };
-                }
-                else {
-                    // eslint-disable-next-line no-console
-                    console.warn(`[useResponseCache] Failed extracting document string from the context. The response will not be cached or served from the cache. ` +
-                        `If you are overriding the 'parse' behavior make sure to pass a custom 'getDocumentStringFromContext' function for getting the document string, which is required for building the response cache key.`);
-                    return undefined;
-                }
-            }
+                                },
+                            });
+                        }
+                        return;
+                    }
+                    cache.set(operationId, result, identifier.values(), finalTtl);
+                    if (includeExtensionMetadata) {
+                        setResult({
+                            ...result,
+                            extensions: {
+                                responseCache: {
+                                    hit: false,
+                                    didCache: true,
+                                    ttl: finalTtl,
+                                },
+                            },
+                        });
+                    }
+                },
+            };
         },
     };
 }
@@ -412,6 +409,6 @@ function applyResponseCacheLogic(schema, idFieldNames) {
 exports.createInMemoryCache = createInMemoryCache;
 exports.defaultBuildEntityId = defaultBuildEntityId;
 exports.defaultBuildResponseCacheKey = defaultBuildResponseCacheKey;
-exports.defaultGetDocumentStringFromContext = defaultGetDocumentStringFromContext;
+exports.defaultGetDocumentString = defaultGetDocumentString;
 exports.defaultShouldCacheResult = defaultShouldCacheResult;
 exports.useResponseCache = useResponseCache;

package/index.mjs

@@ -1,7 +1,7 @@
 import LRU from 'lru-cache';
 import { isAsyncIterable } from '@envelop/core';
 import { mapSchema, MapperKind } from '@graphql-tools/utils';
-import { defaultFieldResolver, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
+import { print, defaultFieldResolver, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
 import jsonStableStringify from 'fast-json-stable-stringify';
 
 const createInMemoryCache = (params) => {
@@ -118,7 +118,7 @@ const hashSHA256 = async (text) => {
     if (nodeCrypto) {
         return nodeCrypto.then(crypto => crypto.createHash('sha256').update(text).digest('hex'));
     }
-    else if (webCrypto) {
+    if (webCrypto) {
         let buf;
         if (typeof TextEncoder !== 'undefined') {
             buf = new TextEncoder().encode(text);
@@ -148,7 +148,6 @@ const hashSHA256 = async (text) => {
 };
 
 const contextSymbol = Symbol('responseCache');
-const rawDocumentStringSymbol = Symbol('rawDocumentString');
 /**
  * Default function used for building the response cache key.
  * It is exported here for advanced use-cases. E.g. if you want to short circuit and serve responses from the cache on a global level in order to completely by-pass the GraphQL flow.
@@ -178,31 +177,40 @@ const defaultShouldCacheResult = (params) => {
     }
     return true;
 };
-const defaultGetDocumentStringFromContext = context => context[rawDocumentStringSymbol];
-function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session = () => null, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = defaultBuildResponseCacheKey, getDocumentStringFromContext = defaultGetDocumentStringFromContext, shouldCacheResult = defaultShouldCacheResult, 
+const documentStringByDocument = new WeakMap();
+function defaultGetDocumentString(executionArgs) {
+    let documentString = documentStringByDocument.get(executionArgs.document);
+    if (!documentString) {
+        documentString = print(executionArgs.document);
+        documentStringByDocument.set(executionArgs.document, documentString);
+    }
+    return documentString;
+}
+function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session = () => null, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = defaultBuildResponseCacheKey, getDocumentString = defaultGetDocumentString, shouldCacheResult = defaultShouldCacheResult, 
 // eslint-disable-next-line dot-notation
 includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_ENV'] === 'development' : false, } = {}) {
+    const appliedTransform = Symbol('responseCache.appliedTransform');
     const ignoredTypesMap = new Set(ignoredTypes);
-    const schemaCache = new WeakMap();
     // never cache Introspections
     ttlPerSchemaCoordinate = { 'Query.__schema': 0, ...ttlPerSchemaCoordinate };
     return {
-        onSchemaChange(ctx) {
-            let schema = schemaCache.get(ctx.schema);
-            if (schema == null) {
-                schema = applyResponseCacheLogic(ctx.schema, idFields);
-                schemaCache.set(ctx.schema, schema);
+        onSchemaChange({ schema, replaceSchema }) {
+            var _a;
+            // @ts-expect-error See https://github.com/graphql/graphql-js/pull/3511 - remove this comments once merged
+            if (((_a = schema.extensions) === null || _a === void 0 ? void 0 : _a[appliedTransform]) === true) {
+                return;
             }
-            ctx.replaceSchema(schema);
+            const patchedSchema = applyResponseCacheLogic(schema, idFields);
+            patchedSchema.extensions = {
+                ...patchedSchema.extensions,
+                [appliedTransform]: true,
+            };
+            replaceSchema(patchedSchema);
         },
-        onParse(parseCtx) {
-            return function onParseEnd(ctx) {
-                if (ctx.result && 'kind' in ctx.result) {
-                    const source = parseCtx.params.source;
-                    const rawDocumentString = typeof source === 'string' ? source : source.body;
-                    ctx.extendContext({
-                        [rawDocumentStringSymbol]: rawDocumentString,
-                    });
+        onParse({ params: { source } }) {
+            return function onParseEnd({ result }) {
+                if (result != null && !(result instanceof Error)) {
+                    documentStringByDocument.set(result, source.toString());
                 }
             };
         },
@@ -247,102 +255,91 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                     },
                 };
             }
-            else {
-                const documentString = getDocumentStringFromContext(ctx.args.contextValue);
-                if (documentString != null) {
-                    const operationId = await buildResponseCacheKey({
-                        documentString,
-                        variableValues: ctx.args.variableValues,
-                        operationName: ctx.args.operationName,
-                        sessionId: session(ctx.args.contextValue),
-                    });
-                    if (((_a = enabled === null || enabled === void 0 ? void 0 : enabled(ctx.args.contextValue)) !== null && _a !== void 0 ? _a : true) === true) {
-                        const cachedResponse = await cache.get(operationId);
-                        if (cachedResponse != null) {
-                            if (includeExtensionMetadata) {
-                                ctx.setResultAndStopExecution({
-                                    ...cachedResponse,
-                                    extensions: {
-                                        responseCache: {
-                                            hit: true,
-                                        },
-                                    },
-                                });
-                            }
-                            else {
-                                ctx.setResultAndStopExecution(cachedResponse);
+            const operationId = await buildResponseCacheKey({
+                documentString: getDocumentString(ctx.args),
+                variableValues: ctx.args.variableValues,
+                operationName: ctx.args.operationName,
+                sessionId: session(ctx.args.contextValue),
+            });
+            if (((_a = enabled === null || enabled === void 0 ? void 0 : enabled(ctx.args.contextValue)) !== null && _a !== void 0 ? _a : true) === true) {
+                const cachedResponse = await cache.get(operationId);
+                if (cachedResponse != null) {
+                    if (includeExtensionMetadata) {
+                        ctx.setResultAndStopExecution({
+                            ...cachedResponse,
+                            extensions: {
+                                responseCache: {
+                                    hit: true,
+                                },
+                            },
+                        });
+                    }
+                    else {
+                        ctx.setResultAndStopExecution(cachedResponse);
+                    }
+                    return;
+                }
+            }
+            if (ttlPerSchemaCoordinate) {
+                const typeInfo = new TypeInfo(ctx.args.schema);
+                visit(ctx.args.document, visitWithTypeInfo(typeInfo, {
+                    Field(fieldNode) {
+                        const parentType = typeInfo.getParentType();
+                        if (parentType) {
+                            const schemaCoordinate = `${parentType.name}.${fieldNode.name.value}`;
+                            const maybeTtl = ttlPerSchemaCoordinate[schemaCoordinate];
+                            if (maybeTtl !== undefined) {
+                                context.currentTtl = calculateTtl(maybeTtl, context.currentTtl);
                             }
-                            return;
                         }
+                    },
+                }));
+            }
+            return {
+                onExecuteDone({ result, setResult }) {
+                    var _a;
+                    if (isAsyncIterable(result)) {
+                        // eslint-disable-next-line no-console
+                        console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
+                        return;
                     }
-                    if (ttlPerSchemaCoordinate) {
-                        const typeInfo = new TypeInfo(ctx.args.schema);
-                        visit(ctx.args.document, visitWithTypeInfo(typeInfo, {
-                            Field(fieldNode) {
-                                const parentType = typeInfo.getParentType();
-                                if (parentType) {
-                                    const schemaCoordinate = `${parentType.name}.${fieldNode.name.value}`;
-                                    const maybeTtl = ttlPerSchemaCoordinate[schemaCoordinate];
-                                    if (maybeTtl !== undefined) {
-                                        context.currentTtl = calculateTtl(maybeTtl, context.currentTtl);
-                                    }
-                                }
-                            },
-                        }));
+                    if (context.skip) {
+                        return;
                     }
-                    return {
-                        onExecuteDone({ result, setResult }) {
-                            var _a;
-                            if (isAsyncIterable(result)) {
-                                // eslint-disable-next-line no-console
-                                console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
-                                return;
-                            }
-                            if (context.skip) {
-                                return;
-                            }
-                            if (!shouldCacheResult({ result })) {
-                                return;
-                            }
-                            // we only use the global ttl if no currentTtl has been determined.
-                            const finalTtl = (_a = context.currentTtl) !== null && _a !== void 0 ? _a : globalTtl;
-                            if (finalTtl === 0) {
-                                if (includeExtensionMetadata) {
-                                    setResult({
-                                        ...result,
-                                        extensions: {
-                                            responseCache: {
-                                                hit: false,
-                                                didCache: false,
-                                            },
-                                        },
-                                    });
-                                }
-                                return;
-                            }
-                            cache.set(operationId, result, identifier.values(), finalTtl);
-                            if (includeExtensionMetadata) {
-                                setResult({
-                                    ...result,
-                                    extensions: {
-                                        responseCache: {
-                                            hit: false,
-                                            didCache: true,
-                                            ttl: finalTtl,
-                                        },
+                    if (!shouldCacheResult({ result })) {
+                        return;
+                    }
+                    // we only use the global ttl if no currentTtl has been determined.
+                    const finalTtl = (_a = context.currentTtl) !== null && _a !== void 0 ? _a : globalTtl;
+                    if (finalTtl === 0) {
+                        if (includeExtensionMetadata) {
+                            setResult({
+                                ...result,
+                                extensions: {
+                                    responseCache: {
+                                        hit: false,
+                                        didCache: false,
                                     },
-                                });
-                            }
-                        },
-                    };
-                }
-                else {
-                    // eslint-disable-next-line no-console
-                    console.warn(`[useResponseCache] Failed extracting document string from the context. The response will not be cached or served from the cache. ` +
-                        `If you are overriding the 'parse' behavior make sure to pass a custom 'getDocumentStringFromContext' function for getting the document string, which is required for building the response cache key.`);
-                    return undefined;
-                }
-            }
+                                },
+                            });
+                        }
+                        return;
+                    }
+                    cache.set(operationId, result, identifier.values(), finalTtl);
+                    if (includeExtensionMetadata) {
+                        setResult({
+                            ...result,
+                            extensions: {
+                                responseCache: {
+                                    hit: false,
+                                    didCache: true,
+                                    ttl: finalTtl,
+                                },
+                            },
+                        });
+                    }
+                },
+            };
         },
     };
 }
@@ -403,4 +400,4 @@ function applyResponseCacheLogic(schema, idFieldNames) {
     });
 }
 
-export { createInMemoryCache, defaultBuildEntityId, defaultBuildResponseCacheKey, defaultGetDocumentStringFromContext, defaultShouldCacheResult, useResponseCache };
+export { createInMemoryCache, defaultBuildEntityId, defaultBuildResponseCacheKey, defaultGetDocumentString, defaultShouldCacheResult, useResponseCache };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@envelop/response-cache",
-  "version": "3.0.0-alpha-4ba70ab.0",
+  "version": "3.0.0-alpha-868cc42.0",
   "sideEffects": false,
   "peerDependencies": {
-    "@envelop/core": "2.1.0-alpha-4ba70ab.0",
+    "@envelop/core": "^2.3.3",
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
@@ -13,7 +13,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/dotansimha/envelop.git",
+    "url": "https://github.com/n1ru4l/envelop.git",
     "directory": "packages/plugins/response-cache"
   },
   "author": "Kamil Kisiela <kamilkisiela@gmail.com>",

package/plugin.d.ts

@@ -1,4 +1,4 @@
-import { Plugin, Maybe, DefaultContext } from '@envelop/core';
+import { Plugin, Maybe } from '@envelop/core';
 import { ExecutionArgs, ExecutionResult } from 'graphql';
 import type { Cache } from './cache';
 /**
@@ -14,7 +14,7 @@ export declare type BuildResponseCacheKeyFunction = (params: {
     /** optional sessionId for make unique cache keys based on the session.  */
     sessionId?: Maybe<string>;
 }) => Promise<string>;
-export declare type GetDocumentStringFromContextFunction = (params: DefaultContext) => Maybe<string>;
+export declare type GetDocumentStringFunction = (executionArgs: ExecutionArgs) => string;
 export declare type ShouldCacheResultFunction = (params: {
     result: ExecutionResult;
 }) => Boolean;
@@ -72,12 +72,13 @@ export declare type UseResponseCacheParameter<C = any> = {
      */
     buildResponseCacheKey?: BuildResponseCacheKeyFunction;
     /**
-     * Function used for reading the document string that is used for building the response cache key from the context object.
-     * By default, the useResponseCache plugin hooks into onParse and writes the original operation string to the context.
+     * Function used for reading the document string that is used for building the response cache key from the execution arguments.
+     * By default, the useResponseCache plugin hooks into onParse and caches the original operation string in a WeakMap.
      * If you are hard overriding parse you need to set this function, otherwise responses will not be cached or served from the cache.
-     * Defaults to `defaultGetDocumentStringFromContext`
+     * Defaults to `defaultGetDocumentString`
+     *
      */
-    getDocumentStringFromContext?: GetDocumentStringFromContextFunction;
+    getDocumentString?: GetDocumentStringFunction;
     /**
      * Include extension values that provide useful information, such as whether the cache was hit or which resources a mutation invalidated.
      * Defaults to `true` if `process.env["NODE_ENV"]` is set to `"development"`, otherwise `false`.
@@ -104,5 +105,5 @@ export declare const defaultBuildResponseCacheKey: BuildResponseCacheKeyFunction
  * By default, results with errors (unexpected, EnvelopError, or GraphQLError) are not cached.
  */
 export declare const defaultShouldCacheResult: ShouldCacheResultFunction;
-export declare const defaultGetDocumentStringFromContext: GetDocumentStringFromContextFunction;
-export declare function useResponseCache({ cache, ttl: globalTtl, session, enabled, ignoredTypes, ttlPerType, ttlPerSchemaCoordinate, idFields, invalidateViaMutation, buildResponseCacheKey, getDocumentStringFromContext, shouldCacheResult, includeExtensionMetadata, }?: UseResponseCacheParameter): Plugin;
+export declare function defaultGetDocumentString(executionArgs: ExecutionArgs): string;
+export declare function useResponseCache({ cache, ttl: globalTtl, session, enabled, ignoredTypes, ttlPerType, ttlPerSchemaCoordinate, idFields, invalidateViaMutation, buildResponseCacheKey, getDocumentString, shouldCacheResult, includeExtensionMetadata, }?: UseResponseCacheParameter): Plugin;