@envelop/response-cache 5.1.0 → 5.2.0-alpha-20230625183613-3b72bf4a

package/cjs/plugin.js

@@ -233,32 +233,63 @@ function useResponseCache({ cache = (0, in_memory_cache_js_1.createInMemoryCache
                     },
                 }));
             }
-            return {
-                onExecuteDone({ result, setResult }) {
-                    if ((0, core_1.isAsyncIterable)(result)) {
-                        // eslint-disable-next-line no-console
-                        console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
-                        return;
-                    }
-                    const processedResult = processResult(result);
-                    if (skip) {
-                        return;
-                    }
-                    if (!shouldCacheResult({ cacheKey, result: processedResult })) {
-                        return;
+            async function maybeCacheResult(result, setResult) {
+                const processedResult = processResult(result);
+                if (skip) {
+                    return;
+                }
+                if (!shouldCacheResult({ cacheKey, result: processedResult })) {
+                    return;
+                }
+                // we only use the global ttl if no currentTtl has been determined.
+                const finalTtl = currentTtl ?? globalTtl;
+                if (finalTtl === 0) {
+                    if (includeExtensionMetadata) {
+                        setResult(resultWithMetadata(processedResult, { hit: false, didCache: false }));
                     }
-                    // we only use the global ttl if no currentTtl has been determined.
-                    const finalTtl = currentTtl ?? globalTtl;
-                    if (finalTtl === 0) {
-                        if (includeExtensionMetadata) {
-                            setResult(resultWithMetadata(processedResult, { hit: false, didCache: false }));
-                        }
+                    return;
+                }
+                cache.set(cacheKey, processedResult, identifier.values(), finalTtl);
+                if (includeExtensionMetadata) {
+                    setResult(resultWithMetadata(processedResult, { hit: false, didCache: true, ttl: finalTtl }));
+                }
+            }
+            return {
+                onExecuteDone(payload) {
+                    if (!(0, core_1.isAsyncIterable)(payload.result)) {
+                        maybeCacheResult(payload.result, payload.setResult);
                         return;
                     }
-                    cache.set(cacheKey, processedResult, identifier.values(), finalTtl);
-                    if (includeExtensionMetadata) {
-                        setResult(resultWithMetadata(processedResult, { hit: false, didCache: true, ttl: finalTtl }));
-                    }
+                    // When the result is an AsyncIterable, it means the query is using @defer or @stream.
+                    // This means we have to build the final result by merging the incremental results.
+                    // The merged result is then used to know if we should cache it and to calculate the ttl.
+                    let result = {};
+                    return {
+                        onNext(payload) {
+                            const { data, errors, extensions, incremental, hasNext } = payload.result;
+                            if (data) {
+                                // This is the first result with the initial data payload sent to the client. We use it as the base result
+                                if (data) {
+                                    result = { data };
+                                }
+                                if (errors) {
+                                    result.errors = errors;
+                                }
+                                if (extensions) {
+                                    result.extensions = extensions;
+                                }
+                            }
+                            if (incremental) {
+                                for (const patch of incremental) {
+                                    mergePatch(result, patch);
+                                }
+                            }
+                            if (!hasNext) {
+                                // The query is complete, we can process the final result
+                                maybeCacheResult(result, payload.setResult);
+                            }
+                        },
+                    };
                 },
             };
         },
@@ -286,3 +317,44 @@ function calculateTtl(typeTtl, currentTtl) {
 exports.cacheControlDirective = `
   directive @cacheControl(maxAge: Int) on FIELD_DEFINITION | OBJECT
 `;
+function mergePatch(result, patch) {
+    // All errors and extensions are merged together in the final result
+    if (patch.errors) {
+        result.errors = [...(result.errors ?? []), ...patch.errors];
+    }
+    if (patch.extensions) {
+        result.extensions = { ...result.extensions, ...patch.extensions };
+    }
+    // We need to follow the path to the point where the patch should be applied
+    let target = result;
+    const path = ['data', ...(patch.path ?? [])];
+    for (let i = 0; i < path.length - 1; i++) {
+        target = target[path[i]];
+    }
+    const prop = path[path.length - 1];
+    const items = patch.items;
+    const data = patch.data;
+    if (items) {
+        // This is a stream patch, the last path segment should be a number and is the index at which we should begin to insert the new items
+        const start = +prop;
+        for (let i = 0; i < items.length; i++) {
+            target[start + i] = deepMerge(target[start + i], items[i]);
+        }
+    }
+    else if (data !== undefined) {
+        // This is a defer patch.
+        target[prop] = deepMerge(target[prop], data);
+    }
+}
+function deepMerge(target, source) {
+    if (typeof target === 'object' && target != null) {
+        target = Array.isArray(target) ? [...target] : { ...target };
+        for (const key of Object.keys(source)) {
+            target[key] = deepMerge(target[key], source[key]);
+        }
+        return target;
+    }
+    else {
+        return source;
+    }
+}

package/esm/plugin.js

@@ -226,32 +226,63 @@ export function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl
                     },
                 }));
             }
-            return {
-                onExecuteDone({ result, setResult }) {
-                    if (isAsyncIterable(result)) {
-                        // eslint-disable-next-line no-console
-                        console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
-                        return;
-                    }
-                    const processedResult = processResult(result);
-                    if (skip) {
-                        return;
-                    }
-                    if (!shouldCacheResult({ cacheKey, result: processedResult })) {
-                        return;
+            async function maybeCacheResult(result, setResult) {
+                const processedResult = processResult(result);
+                if (skip) {
+                    return;
+                }
+                if (!shouldCacheResult({ cacheKey, result: processedResult })) {
+                    return;
+                }
+                // we only use the global ttl if no currentTtl has been determined.
+                const finalTtl = currentTtl ?? globalTtl;
+                if (finalTtl === 0) {
+                    if (includeExtensionMetadata) {
+                        setResult(resultWithMetadata(processedResult, { hit: false, didCache: false }));
                     }
-                    // we only use the global ttl if no currentTtl has been determined.
-                    const finalTtl = currentTtl ?? globalTtl;
-                    if (finalTtl === 0) {
-                        if (includeExtensionMetadata) {
-                            setResult(resultWithMetadata(processedResult, { hit: false, didCache: false }));
-                        }
+                    return;
+                }
+                cache.set(cacheKey, processedResult, identifier.values(), finalTtl);
+                if (includeExtensionMetadata) {
+                    setResult(resultWithMetadata(processedResult, { hit: false, didCache: true, ttl: finalTtl }));
+                }
+            }
+            return {
+                onExecuteDone(payload) {
+                    if (!isAsyncIterable(payload.result)) {
+                        maybeCacheResult(payload.result, payload.setResult);
                         return;
                     }
-                    cache.set(cacheKey, processedResult, identifier.values(), finalTtl);
-                    if (includeExtensionMetadata) {
-                        setResult(resultWithMetadata(processedResult, { hit: false, didCache: true, ttl: finalTtl }));
-                    }
+                    // When the result is an AsyncIterable, it means the query is using @defer or @stream.
+                    // This means we have to build the final result by merging the incremental results.
+                    // The merged result is then used to know if we should cache it and to calculate the ttl.
+                    let result = {};
+                    return {
+                        onNext(payload) {
+                            const { data, errors, extensions, incremental, hasNext } = payload.result;
+                            if (data) {
+                                // This is the first result with the initial data payload sent to the client. We use it as the base result
+                                if (data) {
+                                    result = { data };
+                                }
+                                if (errors) {
+                                    result.errors = errors;
+                                }
+                                if (extensions) {
+                                    result.extensions = extensions;
+                                }
+                            }
+                            if (incremental) {
+                                for (const patch of incremental) {
+                                    mergePatch(result, patch);
+                                }
+                            }
+                            if (!hasNext) {
+                                // The query is complete, we can process the final result
+                                maybeCacheResult(result, payload.setResult);
+                            }
+                        },
+                    };
                 },
             };
         },
@@ -278,3 +309,44 @@ function calculateTtl(typeTtl, currentTtl) {
 export const cacheControlDirective = /* GraphQL */ `
   directive @cacheControl(maxAge: Int) on FIELD_DEFINITION | OBJECT
 `;
+function mergePatch(result, patch) {
+    // All errors and extensions are merged together in the final result
+    if (patch.errors) {
+        result.errors = [...(result.errors ?? []), ...patch.errors];
+    }
+    if (patch.extensions) {
+        result.extensions = { ...result.extensions, ...patch.extensions };
+    }
+    // We need to follow the path to the point where the patch should be applied
+    let target = result;
+    const path = ['data', ...(patch.path ?? [])];
+    for (let i = 0; i < path.length - 1; i++) {
+        target = target[path[i]];
+    }
+    const prop = path[path.length - 1];
+    const items = patch.items;
+    const data = patch.data;
+    if (items) {
+        // This is a stream patch, the last path segment should be a number and is the index at which we should begin to insert the new items
+        const start = +prop;
+        for (let i = 0; i < items.length; i++) {
+            target[start + i] = deepMerge(target[start + i], items[i]);
+        }
+    }
+    else if (data !== undefined) {
+        // This is a defer patch.
+        target[prop] = deepMerge(target[prop], data);
+    }
+}
+function deepMerge(target, source) {
+    if (typeof target === 'object' && target != null) {
+        target = Array.isArray(target) ? [...target] : { ...target };
+        for (const key of Object.keys(source)) {
+            target[key] = deepMerge(target[key], source[key]);
+        }
+        return target;
+    }
+    else {
+        return source;
+    }
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@envelop/response-cache",
-  "version": "5.1.0",
+  "version": "5.2.0-alpha-20230625183613-3b72bf4a",
   "sideEffects": false,
   "peerDependencies": {
-    "@envelop/core": "^4.0.0",
+    "@envelop/core": "4.0.1-alpha-20230625183613-3b72bf4a",
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
+    "@graphql-tools/executor": "^1.1.0",
     "@graphql-tools/utils": "^10.0.0",
     "@whatwg-node/fetch": "^0.9.0",
     "fast-json-stable-stringify": "^2.1.0",