check enable only at execution phase and don't stop execution (#2094)

Author: EmrysMyrddin

.changeset/breezy-pots-lick.md

@@ -0,0 +1,5 @@
+---
+'@envelop/response-cache': patch
+---
+
+Run enabled once only in execution

packages/plugins/response-cache/README.md

@@ -36,6 +36,37 @@ When configuring the `useResponseCache`, you can choose the type of cache:
 - In-Memory LRU Cache (default)
 - Redis Cache (see: `@envelop/response-cache-redis`)
 
+### Note on Plugin ordering
+
+This plugin rely on a custom executor to work. This means that this plugin should in most cases
+placed last in the plugin list. Otherwise, some other plugin might override the custom executor.
+
+For example, this would not work:
+
+```ts
+import { execute, parse, specifiedRules, subscribe, validate } from 'graphql'
+import { envelop, useEngine } from '@envelop/core'
+import { useResponseCache } from '@envelop/response-cache'
+
+// Don't
+const getEnveloped = envelop({
+  plugins: [
+    useResponseCache(),
+    // Here, useEngine will override the `execute` function, leading to a non working cache.
+    useEngine({ parse, validate, specifiedRules, execute, subscribe }),
+  ]
+})
+
+// Do
+const getEnveloped = envelop({
+  plugins: [
+    useEngine({ parse, validate, specifiedRules, execute, subscribe }),
+    // Here, the plugin can control the `execute` function
+    useResponseCache(),
+  ]
+})
+```
+
 ### In-Memory Cache
 
 The in-memory LRU cache is used by default.

packages/plugins/response-cache/src/plugin.ts

@@ -1,5 +1,6 @@
 import jsonStableStringify from 'fast-json-stable-stringify';
 import {
+  ASTVisitor,
   DocumentNode,
   ExecutionArgs,
   getOperationAST,
@@ -16,6 +17,7 @@ import {
   Maybe,
   ObjMap,
   OnExecuteDoneHookResult,
+  OnExecuteHookResult,
   Plugin,
 } from '@envelop/core';
 import {
@@ -205,63 +207,77 @@ export type ResponseCacheExecutionResult = ExecutionResult<
   { responseCache?: ResponseCacheExtensions }
 >;
 
-const originalDocumentMap = new WeakMap<DocumentNode, DocumentNode>();
-const addEntityInfosToDocument = memoize4(function addTypeNameToDocument(
+const getDocumentWithMetadataAndTTL = memoize4(function addTypeNameToDocument(
   document: DocumentNode,
-  addTypeNameToDocumentOpts: { invalidateViaMutation: boolean },
+  {
+    invalidateViaMutation,
+    ttlPerSchemaCoordinate,
+  }: {
+    invalidateViaMutation: boolean;
+    ttlPerSchemaCoordinate?: Record<string, number | undefined>;
+  },
   schema: any,
   idFieldByTypeName: Map<string, string>,
-): DocumentNode {
+): [DocumentNode, number | undefined] {
   const typeInfo = new TypeInfo(schema);
-  const newDocument = visit(
-    document,
-    visitWithTypeInfo(typeInfo, {
-      OperationDefinition: {
-        enter(node): void | false {
-          if (!addTypeNameToDocumentOpts.invalidateViaMutation && node.operation === 'mutation') {
-            return false;
-          }
-          if (node.operation === 'subscription') {
-            return false;
-          }
-        },
+  let ttl: number | undefined;
+  const visitor: ASTVisitor = {
+    OperationDefinition: {
+      enter(node): void | false {
+        if (!invalidateViaMutation && node.operation === 'mutation') {
+          return false;
+        }
+        if (node.operation === 'subscription') {
+          return false;
+        }
       },
-      SelectionSet(node, _key) {
+    },
+    ...(ttlPerSchemaCoordinate != null && {
+      Field(fieldNode) {
         const parentType = typeInfo.getParentType();
-        const idField = parentType && idFieldByTypeName.get(parentType.name);
-        return {
-          ...node,
-          selections: [
-            {
-              kind: Kind.FIELD,
-              name: {
-                kind: Kind.NAME,
-                value: '__typename',
-              },
-              alias: {
-                kind: Kind.NAME,
-                value: '__responseCacheTypeName',
-              },
-            },
-            ...(idField
-              ? [
-                  {
-                    kind: Kind.FIELD,
-                    name: { kind: Kind.NAME, value: idField },
-                    alias: { kind: Kind.NAME, value: '__responseCacheId' },
-                  },
-                ]
-              : []),
-
-            ...node.selections,
-          ],
-        };
+        if (parentType) {
+          const schemaCoordinate = `${parentType.name}.${fieldNode.name.value}`;
+          const maybeTtl = ttlPerSchemaCoordinate[schemaCoordinate];
+          if (maybeTtl !== undefined) {
+            ttl = calculateTtl(maybeTtl, ttl);
+          }
+        }
       },
     }),
-  );
+    SelectionSet(node, _key) {
+      const parentType = typeInfo.getParentType();
+      const idField = parentType && idFieldByTypeName.get(parentType.name);
+      return {
+        ...node,
+        selections: [
+          {
+            kind: Kind.FIELD,
+            name: {
+              kind: Kind.NAME,
+              value: '__typename',
+            },
+            alias: {
+              kind: Kind.NAME,
+              value: '__responseCacheTypeName',
+            },
+          },
+          ...(idField
+            ? [
+                {
+                  kind: Kind.FIELD,
+                  name: { kind: Kind.NAME, value: idField },
+                  alias: { kind: Kind.NAME, value: '__responseCacheId' },
+                },
+              ]
+            : []),
+
+          ...node.selections,
+        ],
+      };
+    },
+  };
 
-  originalDocumentMap.set(newDocument, document);
-  return newDocument;
+  return [visit(document, visitWithTypeInfo(typeInfo, visitor)), ttl];
 });
 
 export function useResponseCache<PluginContext extends Record<string, any> = {}>({
@@ -289,7 +305,10 @@ export function useResponseCache<PluginContext extends Record<string, any> = {}>
 
   // never cache Introspections
   ttlPerSchemaCoordinate = { 'Query.__schema': 0, ...ttlPerSchemaCoordinate };
-  const addTypeNameToDocumentOpts = { invalidateViaMutation };
+  const documentMetadataOptions = {
+    queries: { invalidateViaMutation, ttlPerSchemaCoordinate },
+    mutations: { invalidateViaMutation }, // remove ttlPerSchemaCoordinate for mutations to skip TTL calculation
+  };
   const idFieldByTypeName = new Map<string, string>();
   let schema: any;
 
@@ -303,22 +322,6 @@ export function useResponseCache<PluginContext extends Record<string, any> = {}>
   }
 
   return {
-    onParse() {
-      return ({ result, replaceParseResult, context }) => {
-        if (enabled && !enabled(context)) {
-          return;
-        }
-        if (!originalDocumentMap.has(result) && result.kind === Kind.DOCUMENT) {
-          const newDocument = addEntityInfosToDocument(
-            result,
-            addTypeNameToDocumentOpts,
-            schema,
-            idFieldByTypeName,
-          );
-          replaceParseResult(newDocument);
-        }
-      };
-    },
     onSchemaChange({ schema: newSchema }) {
       if (schema === newSchema) {
         return;
@@ -373,11 +376,35 @@ export function useResponseCache<PluginContext extends Record<string, any> = {}>
       }
       const identifier = new Map<string, CacheEntityRecord>();
       const types = new Set<string>();
+      let currentTtl: number | undefined;
+      let skip = false;
 
       const sessionId = session(onExecuteParams.args.contextValue);
 
-      let currentTtl: number | undefined;
-      let skip = false;
+      function setExecutor({
+        execute,
+        onExecuteDone,
+      }: {
+        execute: typeof onExecuteParams.executeFn;
+        onExecuteDone?: OnExecuteHookResult<PluginContext>['onExecuteDone'];
+      }): OnExecuteHookResult<PluginContext> {
+        let executed = false;
+        onExecuteParams.setExecuteFn(args => {
+          executed = true;
+          return execute(args);
+        });
+        return {
+          onExecuteDone(params) {
+            if (!executed) {
+              // eslint-disable-next-line no-console
+              console.warn(
+                '[useResponseCache] The cached execute function was not called, another plugin might have overwritten it. Please check your plugin order.',
+              );
+            }
+            return onExecuteDone?.(params);
+          },
+        };
+      }
 
       function processResult(data: any) {
         if (data == null || typeof data !== 'object') {
@@ -450,15 +477,24 @@ export function useResponseCache<PluginContext extends Record<string, any> = {}>
         );
 
         if (operationAST?.operation === 'mutation') {
-          return {
+          return setExecutor({
+            execute(args) {
+              const [document] = getDocumentWithMetadataAndTTL(
+                args.document,
+                documentMetadataOptions.mutations,
+                args.schema,
+                idFieldByTypeName,
+              );
+              return onExecuteParams.executeFn({ ...args, document });
+            },
             onExecuteDone({ result, setResult }) {
               if (isAsyncIterable(result)) {
                 return handleAsyncIterableResult(invalidateCache);
               }
 
               return invalidateCache(result, setResult);
             },
-          };
+          });
         }
       }
 
@@ -473,33 +509,12 @@ export function useResponseCache<PluginContext extends Record<string, any> = {}>
       const cachedResponse = (await cache.get(cacheKey)) as ResponseCacheExecutionResult;
 
       if (cachedResponse != null) {
-        if (includeExtensionMetadata) {
-          onExecuteParams.setResultAndStopExecution(
-            resultWithMetadata(cachedResponse, { hit: true }),
-          );
-        } else {
-          onExecuteParams.setResultAndStopExecution(cachedResponse);
-        }
-        return;
-      }
-
-      if (ttlPerSchemaCoordinate) {
-        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) {
-                  currentTtl = calculateTtl(maybeTtl, currentTtl);
-                }
-              }
-            },
-          }),
-        );
+        return setExecutor({
+          execute: () =>
+            includeExtensionMetadata
+              ? resultWithMetadata(cachedResponse, { hit: true })
+              : cachedResponse,
+        });
       }
 
       function maybeCacheResult(
@@ -523,15 +538,25 @@ export function useResponseCache<PluginContext extends Record<string, any> = {}>
         }
       }
 
-      return {
+      return setExecutor({
+        execute(args) {
+          const [document, ttl] = getDocumentWithMetadataAndTTL(
+            args.document,
+            documentMetadataOptions.queries,
+            schema,
+            idFieldByTypeName,
+          );
+          currentTtl = ttl;
+          return onExecuteParams.executeFn({ ...args, document });
+        },
         onExecuteDone({ result, setResult }) {
           if (isAsyncIterable(result)) {
             return handleAsyncIterableResult(maybeCacheResult);
           }
 
           return maybeCacheResult(result, setResult);
         },
-      };
+      });
     },
   };
 }