@envelop/response-cache 3.0.0-alpha-9e9dfbb.0 → 3.0.0-alpha-e41b2ae.0

package/README.md

@@ -38,35 +38,37 @@ When configuring the `useResponseCache`, you can choose the type of cache:
 The in-memory LRU cache is used by default.
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     useResponseCache({
       // use global cache for all operations
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 Or, you may create the in-memory LRU cache explicitly.
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache, createInMemoryCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache, createInMemoryCache } from '@envelop/response-cache'
 
-const cache = createInMemoryCache();
+const cache = createInMemoryCache()
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
-    useResponseCache({ cache }),
-    session: () => null, // use global cache for all operations
-  ],
-});
+    useResponseCache({
+      cache,
+      session: () => null // use global cache for all operations
+    })
+  ]
+})
 ```
 
 > Note: The in-memory LRU cache is not suitable for serverless deployments. Instead, consider the Redis cache provided by `@envelop/response-cache-redis`.
@@ -74,8 +76,8 @@ const getEnveloped = envelop({
 ### Cache based on session/user
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
@@ -83,10 +85,10 @@ const getEnveloped = envelop({
     useResponseCache({
       ttl: 2000,
       // context is the GraphQL context used for execution
-      session: context => String(context.user?.id),
-    }),
-  ],
-});
+      session: context => String(context.user?.id)
+    })
+  ]
+})
 ```
 
 ### Redis Cache
@@ -103,31 +105,31 @@ In order to use the Redis cache, you need to:
 - Create an instance of the Redis Cache and set to the `useResponseCache` plugin options
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
-import { createRedisCache } from '@envelop/response-cache-redis';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
+import { createRedisCache } from '@envelop/response-cache-redis'
 
-import Redis from 'ioredis';
+import Redis from 'ioredis'
 
 const redis = new Redis({
   host: 'my-redis-db.example.com',
   port: '30652',
-  password: '1234567890',
-});
+  password: '1234567890'
+})
 
-const redis = new Redis('rediss://:1234567890@my-redis-db.example.com:30652');
+const redis = new Redis('rediss://:1234567890@my-redis-db.example.com:30652')
 
-const cache = createRedisCache({ redis });
+const cache = createRedisCache({ redis })
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     useResponseCache({
       cache,
-      session: () => null, // use global cache for all operations
-    }),
-  ],
-});
+      session: () => null // use global cache for all operations
+    })
+  ]
+})
 ```
 
 > Note: In the Recipes below, be sure to provide your Redis `cache` instance with `useResponseCache({ cache })`.
@@ -137,18 +139,18 @@ const getEnveloped = envelop({
 ### Cache with maximum TTL
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     useResponseCache({
       ttl: 2000, // cached execution results become stale after 2 seconds
-      session: () => null, // use global cache for all operations
-    }),
-  ],
-});
+      session: () => null // use global cache for all operations
+    })
+  ]
+})
 ```
 
 > Note: Setting `ttl: 0` will disable TTL for all types. You can use that if you wish to disable caching for all type, and then enable caching for specific types using `ttlPerType`.
@@ -156,8 +158,8 @@ const getEnveloped = envelop({
 ### Cache with custom TTL per object type
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
@@ -166,18 +168,18 @@ const getEnveloped = envelop({
       ttl: 2000,
       ttlPerType: {
         // cached execution results that contain a `Stock` object become stale after 500ms
-        Stock: 500,
-      },
-    }),
-  ],
-});
+        Stock: 500
+      }
+    })
+  ]
+})
 ```
 
 ### Cache with custom TTL per schema coordinate
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
@@ -186,18 +188,18 @@ const getEnveloped = envelop({
       ttl: 2000,
       ttlPerSchemaCoordinate: {
         // cached execution results that select the `Query.user` field become stale after 100ms
-        'Query.rocketCoordinates': 100,
-      },
-    }),
-  ],
-});
+        'Query.rocketCoordinates': 100
+      }
+    })
+  ]
+})
 ```
 
 ### Disable cache based on session/user
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
@@ -206,10 +208,10 @@ const getEnveloped = envelop({
       ttl: 2000,
       // context is the GraphQL context used for execution
       enabled: context => context.user?.role !== 'admin',
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 ### Customize if result should be cached
@@ -217,7 +219,7 @@ const getEnveloped = envelop({
 You can define a custom function used to check if a query operation execution result should be cached.
 
 ```ts
-type ShouldCacheResultFunction = (params: { result: ExecutionResult }) => Boolean;
+type ShouldCacheResultFunction = (params: { result: ExecutionResult }) => boolean
 ```
 
 This is useful for advanced use-cases. E.g. if you want to
@@ -226,24 +228,24 @@ cache results with certain error types.
 By default, the `defaultShouldCacheResult` function is used which never caches any query operation execution results that includes any errors (unexpected, EnvelopError, or GraphQLError).
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache, ShouldCacheResultFunction } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache, ShouldCacheResultFunction } from '@envelop/response-cache'
 
 export const defaultShouldCacheResult: ShouldCacheResultFunction = (params): Boolean => {
   // cache any query operation execution result
   // even if it includes errors
-  return true;
-};
+  return true
+}
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     useResponseCache({
-      shouldCacheResult = myCustomShouldCacheResult,
-      session: () => null,
-    }),
-  ],
-});
+      shouldCacheResult: myCustomShouldCacheResult,
+      session: () => null
+    })
+  ]
+})
 ```
 
 ### Cache Introspection query operations
@@ -253,63 +255,63 @@ By default introspection query operations are not cached. In case you want to ca
 **Infinite caching**
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     useResponseCache({
       ttlPerSchemaCoordinate: {
-        'Query.__schema': undefined, // cache infinitely
+        'Query.__schema': undefined // cache infinitely
       },
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 **TTL caching**
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     useResponseCache({
       ttlPerSchemaCoordinate: {
-        'Query.__schema': 10_000, // cache for 10 seconds
+        'Query.__schema': 10_000 // cache for 10 seconds
       },
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 ### Cache with maximum TTL
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
     // ... other plugins ...
     useResponseCache({
       ttl: 2000, // cached execution results become stale after 2 seconds
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 ### Customize the fields that are used for building the cache ID
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
@@ -318,17 +320,17 @@ const getEnveloped = envelop({
       ttl: 2000,
       // use the `_id` instead of `id` field.
       idFields: ['_id'],
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 ### Disable automatic cache invalidation via mutations
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache } from '@envelop/response-cache';
+import { envelop } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
 
 const getEnveloped = envelop({
   plugins: [
@@ -337,21 +339,21 @@ const getEnveloped = envelop({
       ttl: 2000,
       // some might prefer invalidating based on a database write log
       invalidateViaMutation: false,
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 ### Invalidate Cache based on custom logic
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache, createInMemoryCache } from '@envelop/response-cache';
-import { emitter } from './eventEmitter';
+import { envelop } from '@envelop/core'
+import { useResponseCache, createInMemoryCache } from '@envelop/response-cache'
+import { emitter } from './eventEmitter'
 
 // we create our cache instance, which allows calling all methods on it
-const cache = createInMemoryCache();
+const cache = createInMemoryCache()
 
 const getEnveloped = envelop({
   plugins: [
@@ -360,33 +362,33 @@ const getEnveloped = envelop({
       ttl: 2000,
       // we pass the cache instance to the request.
       cache,
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 
 emitter.on('invalidate', resource => {
   cache.invalidate([
     {
       typename: resource.type,
-      id: resource.id,
-    },
-  ]);
-});
+      id: resource.id
+    }
+  ])
+})
 ```
 
 ### Customize how cache ids are built
 
 ```ts
-import { envelop } from '@envelop/core';
-import { useResponseCache, createInMemoryCache } from '@envelop/response-cache';
-import { emitter } from './eventEmitter';
+import { envelop } from '@envelop/core'
+import { useResponseCache, createInMemoryCache } from '@envelop/response-cache'
+import { emitter } from './eventEmitter'
 
 // we create our cache instance, which allows calling all methods on it
 const cache = createInMemoryCache({
   // in relay we have global unique ids, no need to use `typename:id`
-  makeId: (typename, id) => id ?? typename,
-});
+  makeId: (typename, id) => id ?? typename
+})
 
 const getEnveloped = envelop({
   plugins: [
@@ -395,10 +397,10 @@ const getEnveloped = envelop({
       ttl: 2000,
       // we pass the cache instance to the request.
       cache,
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 ### Expose cache metadata via extensions
@@ -412,10 +414,10 @@ const getEnveloped = envelop({
     useResponseCache({
       ttl: 2000,
       includeExtensionMetadata: true,
-      session: () => null,
-    }),
-  ],
-});
+      session: () => null
+    })
+  ]
+})
 ```
 
 This option will attach the following fields to the execution result if set to true (or `process.env["NODE_ENV"]` is `"development"`).

package/cjs/plugin.js

@@ -9,7 +9,6 @@ const fast_json_stable_stringify_1 = tslib_1.__importDefault(require("fast-json-
 const in_memory_cache_js_1 = require("./in-memory-cache.js");
 const hashSHA256_js_1 = require("./hashSHA256.js");
 const cache_document_str_js_1 = require("./cache-document-str.js");
-const contextSymbol = Symbol('responseCache');
 /**
  * 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.
@@ -44,7 +43,6 @@ exports.defaultShouldCacheResult = defaultShouldCacheResult;
 function useResponseCache({ cache = (0, in_memory_cache_js_1.createInMemoryCache)(), ttl: globalTtl = Infinity, session, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = exports.defaultBuildResponseCacheKey, getDocumentString = cache_document_str_js_1.defaultGetDocumentString, shouldCacheResult = exports.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);
     // never cache Introspections
     ttlPerSchemaCoordinate = { 'Query.__schema': 0, ...ttlPerSchemaCoordinate };
@@ -54,38 +52,106 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                 addPlugin((0, cache_document_str_js_1.useCacheDocumentString)());
             }
         },
-        onSchemaChange({ schema, replaceSchema }) {
+        async onExecute(onExecuteParams) {
             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;
+            let documentChanged = false;
+            const newDocument = (0, graphql_1.visit)(onExecuteParams.args.document, {
+                SelectionSet(node) {
+                    if (!node.selections.some(selection => selection.kind === graphql_1.Kind.FIELD && selection.name.value === '__typename')) {
+                        documentChanged = true;
+                        return {
+                            ...node,
+                            selections: [
+                                {
+                                    kind: graphql_1.Kind.FIELD,
+                                    name: {
+                                        kind: graphql_1.Kind.NAME,
+                                        value: '__typename',
+                                    },
+                                },
+                                ...node.selections,
+                            ],
+                        };
+                    }
+                    return node;
+                },
+            });
+            if (documentChanged) {
+                onExecuteParams.setExecuteFn(function typeNameAddedExecute() {
+                    return onExecuteParams.executeFn({
+                        ...onExecuteParams.args,
+                        document: newDocument,
+                    });
+                });
             }
-            const patchedSchema = applyResponseCacheLogic(schema, idFields);
-            patchedSchema.extensions = {
-                ...patchedSchema.extensions,
-                [appliedTransform]: true,
-            };
-            replaceSchema(patchedSchema);
-        },
-        async onExecute(ctx) {
-            var _a;
             const identifier = new Map();
             const types = new Set();
-            const context = {
-                identifier,
-                types,
-                currentTtl: undefined,
-                ttlPerType,
-                ignoredTypesMap,
-                skip: false,
+            let currentTtl;
+            let skip = false;
+            const processResult = (result) => {
+                var _a;
+                return (0, utils_1.visitResult)(result, {
+                    document: onExecuteParams.args.document,
+                    variables: onExecuteParams.args.variableValues,
+                    operationName: (_a = onExecuteParams.args.operationName) !== null && _a !== void 0 ? _a : undefined,
+                    rootValue: onExecuteParams.args.rootValue,
+                    context: onExecuteParams.args.contextValue,
+                }, onExecuteParams.args.schema, new Proxy({}, {
+                    get(_, typename) {
+                        let typenameCalled = 0;
+                        return new Proxy((val) => val, {
+                            // Needed for leaf values such as scalars, enums etc
+                            // They don't have fields so visitResult expects functions for those
+                            apply(_, __, [val]) {
+                                return val;
+                            },
+                            get(_, fieldName) {
+                                if (documentChanged) {
+                                    if (fieldName === '__typename') {
+                                        typenameCalled++;
+                                    }
+                                    if (fieldName === '__leave') {
+                                        /**
+                                         * The visitResult function is called for each field in the selection set.
+                                         * But visitResult function looks for __typename field visitor even if it is not there in the document
+                                         * So it calls __typename field visitor twice if it is also in the selection set.
+                                         * That's why we need to count the number of times it is called.
+                                         *
+                                         * Default call of __typename https://github.com/ardatan/graphql-tools/blob/master/packages/utils/src/visitResult.ts#L277
+                                         * Call for the field node https://github.com/ardatan/graphql-tools/blob/master/packages/utils/src/visitResult.ts#L272
+                                         */
+                                        if (typenameCalled < 2) {
+                                            return (root) => {
+                                                delete root.__typename;
+                                                return root;
+                                            };
+                                        }
+                                    }
+                                }
+                                if (idFields.includes(fieldName)) {
+                                    if (ignoredTypesMap.has(typename)) {
+                                        skip = true;
+                                    }
+                                    if (skip === true) {
+                                        return;
+                                    }
+                                    return (id) => {
+                                        identifier.set(`${typename}:${id}`, { typename, id });
+                                        types.add(typename);
+                                        if (typename in ttlPerType) {
+                                            currentTtl = calculateTtl(ttlPerType[typename], currentTtl);
+                                        }
+                                        return id;
+                                    };
+                                }
+                                return undefined;
+                            },
+                        });
+                    },
+                }));
             };
-            ctx.extendContext({
-                [contextSymbol]: context,
-            });
-            if (isMutation(ctx.args.document)) {
-                if (invalidateViaMutation === false) {
-                    return;
-                }
+            const operationAST = (0, graphql_1.getOperationAST)(onExecuteParams.args.document, onExecuteParams.args.operationName);
+            if (invalidateViaMutation !== false && (operationAST === null || operationAST === void 0 ? void 0 : operationAST.operation) === 'mutation') {
                 return {
                     onExecuteDone({ result, setResult }) {
                         if ((0, core_1.isAsyncIterable)(result)) {
@@ -93,14 +159,15 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                             console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
                             return;
                         }
-                        cache.invalidate(context.identifier.values());
+                        const processedResult = processResult(result);
+                        cache.invalidate(identifier.values());
                         if (includeExtensionMetadata) {
                             setResult({
-                                ...result,
+                                ...processedResult,
                                 extensions: {
-                                    ...result.extensions,
+                                    ...processedResult.extensions,
                                     responseCache: {
-                                        invalidatedEntities: Array.from(context.identifier.values()),
+                                        invalidatedEntities: Array.from(identifier.values()),
                                     },
                                 },
                             });
@@ -109,16 +176,16 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                 };
             }
             const operationId = await buildResponseCacheKey({
-                documentString: getDocumentString(ctx.args),
-                variableValues: ctx.args.variableValues,
-                operationName: ctx.args.operationName,
-                sessionId: session(ctx.args.contextValue),
+                documentString: getDocumentString(onExecuteParams.args),
+                variableValues: onExecuteParams.args.variableValues,
+                operationName: onExecuteParams.args.operationName,
+                sessionId: session(onExecuteParams.args.contextValue),
             });
-            if (((_a = enabled === null || enabled === void 0 ? void 0 : enabled(ctx.args.contextValue)) !== null && _a !== void 0 ? _a : true) === true) {
+            if (((_a = enabled === null || enabled === void 0 ? void 0 : enabled(onExecuteParams.args.contextValue)) !== null && _a !== void 0 ? _a : true) === true) {
                 const cachedResponse = await cache.get(operationId);
                 if (cachedResponse != null) {
                     if (includeExtensionMetadata) {
-                        ctx.setResultAndStopExecution({
+                        onExecuteParams.setResultAndStopExecution({
                             ...cachedResponse,
                             extensions: {
                                 responseCache: {
@@ -128,21 +195,21 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                         });
                     }
                     else {
-                        ctx.setResultAndStopExecution(cachedResponse);
+                        onExecuteParams.setResultAndStopExecution(cachedResponse);
                     }
                     return;
                 }
             }
             if (ttlPerSchemaCoordinate) {
-                const typeInfo = new graphql_1.TypeInfo(ctx.args.schema);
-                (0, graphql_1.visit)(ctx.args.document, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+                const typeInfo = new graphql_1.TypeInfo(onExecuteParams.args.schema);
+                (0, graphql_1.visit)(onExecuteParams.args.document, (0, graphql_1.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);
+                                currentTtl = calculateTtl(maybeTtl, currentTtl);
                             }
                         }
                     },
@@ -150,24 +217,24 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
             }
             return {
                 onExecuteDone({ result, setResult }) {
-                    var _a;
                     if ((0, core_1.isAsyncIterable)(result)) {
                         // eslint-disable-next-line no-console
                         console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
                         return;
                     }
-                    if (context.skip) {
+                    const processedResult = processResult(result);
+                    if (skip) {
                         return;
                     }
-                    if (!shouldCacheResult({ result })) {
+                    if (!shouldCacheResult({ result: processedResult })) {
                         return;
                     }
                     // we only use the global ttl if no currentTtl has been determined.
-                    const finalTtl = (_a = context.currentTtl) !== null && _a !== void 0 ? _a : globalTtl;
+                    const finalTtl = currentTtl !== null && currentTtl !== void 0 ? currentTtl : globalTtl;
                     if (finalTtl === 0) {
                         if (includeExtensionMetadata) {
                             setResult({
-                                ...result,
+                                ...processedResult,
                                 extensions: {
                                     responseCache: {
                                         hit: false,
@@ -178,10 +245,10 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                         }
                         return;
                     }
-                    cache.set(operationId, result, identifier.values(), finalTtl);
+                    cache.set(operationId, processedResult, identifier.values(), finalTtl);
                     if (includeExtensionMetadata) {
                         setResult({
-                            ...result,
+                            ...processedResult,
                             extensions: {
                                 responseCache: {
                                     hit: false,
@@ -197,59 +264,9 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
     };
 }
 exports.useResponseCache = useResponseCache;
-function isOperationDefinition(node) {
-    return (node === null || node === void 0 ? void 0 : node.kind) === 'OperationDefinition';
-}
 function calculateTtl(typeTtl, currentTtl) {
     if (typeof currentTtl === 'number') {
         return Math.min(currentTtl, typeTtl);
     }
     return typeTtl;
 }
-function isMutation(doc) {
-    return doc.definitions.find(isOperationDefinition).operation === 'mutation';
-}
-function runWith(input, callback) {
-    if (input instanceof Promise) {
-        input.then(callback, () => undefined);
-    }
-    else {
-        callback(input);
-    }
-}
-function applyResponseCacheLogic(schema, idFieldNames) {
-    return (0, utils_1.mapSchema)(schema, {
-        [utils_1.MapperKind.OBJECT_FIELD](fieldConfig, fieldName, typename) {
-            if (idFieldNames.includes(fieldName)) {
-                return {
-                    ...fieldConfig,
-                    resolve(src, args, context, info) {
-                        var _a;
-                        const result = ((_a = fieldConfig.resolve) !== null && _a !== void 0 ? _a : graphql_1.defaultFieldResolver)(src, args, context, info);
-                        runWith(result, (id) => {
-                            const ctx = context[contextSymbol];
-                            if (ctx !== undefined) {
-                                if (ctx.ignoredTypesMap.has(typename)) {
-                                    ctx.skip = true;
-                                }
-                                if (ctx.skip === true) {
-                                    ctx.skip = true;
-                                    return;
-                                }
-                                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                                // @ts-ignore  TODO: investigate what to do if id is something unexpected
-                                ctx.identifier.set(`${typename}:${id}`, { typename, id });
-                                ctx.types.add(typename);
-                                if (typename in ctx.ttlPerType) {
-                                    ctx.currentTtl = calculateTtl(ctx.ttlPerType[typename], ctx.currentTtl);
-                                }
-                            }
-                        });
-                        return result;
-                    },
-                };
-            }
-            return fieldConfig;
-        },
-    });
-}

package/esm/plugin.js

@@ -1,11 +1,10 @@
 import { isAsyncIterable } from '@envelop/core';
-import { MapperKind, mapSchema } from '@graphql-tools/utils';
-import { visit, TypeInfo, visitWithTypeInfo, defaultFieldResolver, } from 'graphql';
+import { visitResult } from '@graphql-tools/utils';
+import { visit, TypeInfo, visitWithTypeInfo, getOperationAST, Kind, } from 'graphql';
 import jsonStableStringify from 'fast-json-stable-stringify';
 import { createInMemoryCache } from './in-memory-cache.js';
 import { hashSHA256 } from './hashSHA256.js';
 import { defaultGetDocumentString, useCacheDocumentString } from './cache-document-str.js';
-const contextSymbol = Symbol('responseCache');
 /**
  * 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.
@@ -38,7 +37,6 @@ export const defaultShouldCacheResult = (params) => {
 export function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session, 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);
     // never cache Introspections
     ttlPerSchemaCoordinate = { 'Query.__schema': 0, ...ttlPerSchemaCoordinate };
@@ -48,38 +46,106 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                 addPlugin(useCacheDocumentString());
             }
         },
-        onSchemaChange({ schema, replaceSchema }) {
+        async onExecute(onExecuteParams) {
             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;
+            let documentChanged = false;
+            const newDocument = visit(onExecuteParams.args.document, {
+                SelectionSet(node) {
+                    if (!node.selections.some(selection => selection.kind === Kind.FIELD && selection.name.value === '__typename')) {
+                        documentChanged = true;
+                        return {
+                            ...node,
+                            selections: [
+                                {
+                                    kind: Kind.FIELD,
+                                    name: {
+                                        kind: Kind.NAME,
+                                        value: '__typename',
+                                    },
+                                },
+                                ...node.selections,
+                            ],
+                        };
+                    }
+                    return node;
+                },
+            });
+            if (documentChanged) {
+                onExecuteParams.setExecuteFn(function typeNameAddedExecute() {
+                    return onExecuteParams.executeFn({
+                        ...onExecuteParams.args,
+                        document: newDocument,
+                    });
+                });
             }
-            const patchedSchema = applyResponseCacheLogic(schema, idFields);
-            patchedSchema.extensions = {
-                ...patchedSchema.extensions,
-                [appliedTransform]: true,
-            };
-            replaceSchema(patchedSchema);
-        },
-        async onExecute(ctx) {
-            var _a;
             const identifier = new Map();
             const types = new Set();
-            const context = {
-                identifier,
-                types,
-                currentTtl: undefined,
-                ttlPerType,
-                ignoredTypesMap,
-                skip: false,
+            let currentTtl;
+            let skip = false;
+            const processResult = (result) => {
+                var _a;
+                return visitResult(result, {
+                    document: onExecuteParams.args.document,
+                    variables: onExecuteParams.args.variableValues,
+                    operationName: (_a = onExecuteParams.args.operationName) !== null && _a !== void 0 ? _a : undefined,
+                    rootValue: onExecuteParams.args.rootValue,
+                    context: onExecuteParams.args.contextValue,
+                }, onExecuteParams.args.schema, new Proxy({}, {
+                    get(_, typename) {
+                        let typenameCalled = 0;
+                        return new Proxy((val) => val, {
+                            // Needed for leaf values such as scalars, enums etc
+                            // They don't have fields so visitResult expects functions for those
+                            apply(_, __, [val]) {
+                                return val;
+                            },
+                            get(_, fieldName) {
+                                if (documentChanged) {
+                                    if (fieldName === '__typename') {
+                                        typenameCalled++;
+                                    }
+                                    if (fieldName === '__leave') {
+                                        /**
+                                         * The visitResult function is called for each field in the selection set.
+                                         * But visitResult function looks for __typename field visitor even if it is not there in the document
+                                         * So it calls __typename field visitor twice if it is also in the selection set.
+                                         * That's why we need to count the number of times it is called.
+                                         *
+                                         * Default call of __typename https://github.com/ardatan/graphql-tools/blob/master/packages/utils/src/visitResult.ts#L277
+                                         * Call for the field node https://github.com/ardatan/graphql-tools/blob/master/packages/utils/src/visitResult.ts#L272
+                                         */
+                                        if (typenameCalled < 2) {
+                                            return (root) => {
+                                                delete root.__typename;
+                                                return root;
+                                            };
+                                        }
+                                    }
+                                }
+                                if (idFields.includes(fieldName)) {
+                                    if (ignoredTypesMap.has(typename)) {
+                                        skip = true;
+                                    }
+                                    if (skip === true) {
+                                        return;
+                                    }
+                                    return (id) => {
+                                        identifier.set(`${typename}:${id}`, { typename, id });
+                                        types.add(typename);
+                                        if (typename in ttlPerType) {
+                                            currentTtl = calculateTtl(ttlPerType[typename], currentTtl);
+                                        }
+                                        return id;
+                                    };
+                                }
+                                return undefined;
+                            },
+                        });
+                    },
+                }));
             };
-            ctx.extendContext({
-                [contextSymbol]: context,
-            });
-            if (isMutation(ctx.args.document)) {
-                if (invalidateViaMutation === false) {
-                    return;
-                }
+            const operationAST = getOperationAST(onExecuteParams.args.document, onExecuteParams.args.operationName);
+            if (invalidateViaMutation !== false && (operationAST === null || operationAST === void 0 ? void 0 : operationAST.operation) === 'mutation') {
                 return {
                     onExecuteDone({ result, setResult }) {
                         if (isAsyncIterable(result)) {
@@ -87,14 +153,15 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                             console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
                             return;
                         }
-                        cache.invalidate(context.identifier.values());
+                        const processedResult = processResult(result);
+                        cache.invalidate(identifier.values());
                         if (includeExtensionMetadata) {
                             setResult({
-                                ...result,
+                                ...processedResult,
                                 extensions: {
-                                    ...result.extensions,
+                                    ...processedResult.extensions,
                                     responseCache: {
-                                        invalidatedEntities: Array.from(context.identifier.values()),
+                                        invalidatedEntities: Array.from(identifier.values()),
                                     },
                                 },
                             });
@@ -103,16 +170,16 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                 };
             }
             const operationId = await buildResponseCacheKey({
-                documentString: getDocumentString(ctx.args),
-                variableValues: ctx.args.variableValues,
-                operationName: ctx.args.operationName,
-                sessionId: session(ctx.args.contextValue),
+                documentString: getDocumentString(onExecuteParams.args),
+                variableValues: onExecuteParams.args.variableValues,
+                operationName: onExecuteParams.args.operationName,
+                sessionId: session(onExecuteParams.args.contextValue),
             });
-            if (((_a = enabled === null || enabled === void 0 ? void 0 : enabled(ctx.args.contextValue)) !== null && _a !== void 0 ? _a : true) === true) {
+            if (((_a = enabled === null || enabled === void 0 ? void 0 : enabled(onExecuteParams.args.contextValue)) !== null && _a !== void 0 ? _a : true) === true) {
                 const cachedResponse = await cache.get(operationId);
                 if (cachedResponse != null) {
                     if (includeExtensionMetadata) {
-                        ctx.setResultAndStopExecution({
+                        onExecuteParams.setResultAndStopExecution({
                             ...cachedResponse,
                             extensions: {
                                 responseCache: {
@@ -122,21 +189,21 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                         });
                     }
                     else {
-                        ctx.setResultAndStopExecution(cachedResponse);
+                        onExecuteParams.setResultAndStopExecution(cachedResponse);
                     }
                     return;
                 }
             }
             if (ttlPerSchemaCoordinate) {
-                const typeInfo = new TypeInfo(ctx.args.schema);
-                visit(ctx.args.document, visitWithTypeInfo(typeInfo, {
+                const typeInfo = new TypeInfo(onExecuteParams.args.schema);
+                visit(onExecuteParams.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);
+                                currentTtl = calculateTtl(maybeTtl, currentTtl);
                             }
                         }
                     },
@@ -144,24 +211,24 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
             }
             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) {
+                    const processedResult = processResult(result);
+                    if (skip) {
                         return;
                     }
-                    if (!shouldCacheResult({ result })) {
+                    if (!shouldCacheResult({ result: processedResult })) {
                         return;
                     }
                     // we only use the global ttl if no currentTtl has been determined.
-                    const finalTtl = (_a = context.currentTtl) !== null && _a !== void 0 ? _a : globalTtl;
+                    const finalTtl = currentTtl !== null && currentTtl !== void 0 ? currentTtl : globalTtl;
                     if (finalTtl === 0) {
                         if (includeExtensionMetadata) {
                             setResult({
-                                ...result,
+                                ...processedResult,
                                 extensions: {
                                     responseCache: {
                                         hit: false,
@@ -172,10 +239,10 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                         }
                         return;
                     }
-                    cache.set(operationId, result, identifier.values(), finalTtl);
+                    cache.set(operationId, processedResult, identifier.values(), finalTtl);
                     if (includeExtensionMetadata) {
                         setResult({
-                            ...result,
+                            ...processedResult,
                             extensions: {
                                 responseCache: {
                                     hit: false,
@@ -190,59 +257,9 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
         },
     };
 }
-function isOperationDefinition(node) {
-    return (node === null || node === void 0 ? void 0 : node.kind) === 'OperationDefinition';
-}
 function calculateTtl(typeTtl, currentTtl) {
     if (typeof currentTtl === 'number') {
         return Math.min(currentTtl, typeTtl);
     }
     return typeTtl;
 }
-function isMutation(doc) {
-    return doc.definitions.find(isOperationDefinition).operation === 'mutation';
-}
-function runWith(input, callback) {
-    if (input instanceof Promise) {
-        input.then(callback, () => undefined);
-    }
-    else {
-        callback(input);
-    }
-}
-function applyResponseCacheLogic(schema, idFieldNames) {
-    return mapSchema(schema, {
-        [MapperKind.OBJECT_FIELD](fieldConfig, fieldName, typename) {
-            if (idFieldNames.includes(fieldName)) {
-                return {
-                    ...fieldConfig,
-                    resolve(src, args, context, info) {
-                        var _a;
-                        const result = ((_a = fieldConfig.resolve) !== null && _a !== void 0 ? _a : defaultFieldResolver)(src, args, context, info);
-                        runWith(result, (id) => {
-                            const ctx = context[contextSymbol];
-                            if (ctx !== undefined) {
-                                if (ctx.ignoredTypesMap.has(typename)) {
-                                    ctx.skip = true;
-                                }
-                                if (ctx.skip === true) {
-                                    ctx.skip = true;
-                                    return;
-                                }
-                                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                                // @ts-ignore  TODO: investigate what to do if id is something unexpected
-                                ctx.identifier.set(`${typename}:${id}`, { typename, id });
-                                ctx.types.add(typename);
-                                if (typename in ctx.ttlPerType) {
-                                    ctx.currentTtl = calculateTtl(ctx.ttlPerType[typename], ctx.currentTtl);
-                                }
-                            }
-                        });
-                        return result;
-                    },
-                };
-            }
-            return fieldConfig;
-        },
-    });
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envelop/response-cache",
-  "version": "3.0.0-alpha-9e9dfbb.0",
+  "version": "3.0.0-alpha-e41b2ae.0",
   "sideEffects": false,
   "peerDependencies": {
     "@envelop/core": "^2.4.0",

package/typings/plugin.d.ts

@@ -45,6 +45,20 @@ export declare type UseResponseCacheParameter<C = any> = {
      * Return `null` or `undefined` to mark the session as public/global.
      * Creates a global session by default.
      * @param context GraphQL Context
+     *
+     * **Global Example:**
+     * ```ts
+     * useResponseCache({
+     *   session: () => null,
+     * });
+     * ```
+     *
+     * **User Specific with global fallback example:**
+     * ```ts
+     * useResponseCache({
+     *   session: (context) => context.user?.id ?? null,
+     * });
+     * ```
      */
     session(context: C): string | undefined | null;
     /**