@envelop/response-cache 2.4.0-alpha-db79afa.0 → 2.4.0-alpha-05dbec7.0

package/esm/plugin.js

@@ -0,0 +1,262 @@
+import { isAsyncIterable } from '@envelop/core';
+import { MapperKind, mapSchema } from '@graphql-tools/utils';
+import { visit, TypeInfo, visitWithTypeInfo, defaultFieldResolver, } from 'graphql';
+import jsonStableStringify from 'fast-json-stable-stringify';
+import { createInMemoryCache } from './in-memory-cache.js';
+import { hashSHA256 } from './hashSHA256.js';
+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.
+ */
+export const defaultBuildResponseCacheKey = params => {
+    var _a, _b, _c;
+    return hashSHA256([
+        params.documentString,
+        (_a = params.operationName) !== null && _a !== void 0 ? _a : '',
+        jsonStableStringify((_b = params.variableValues) !== null && _b !== void 0 ? _b : {}),
+        (_c = params.sessionId) !== null && _c !== void 0 ? _c : '',
+    ].join('|'));
+};
+/**
+ * Default function used to check if the result should be cached.
+ *
+ * It is exported here for advanced use-cases. E.g. if you want to choose if
+ * results with certain error types should be cached.
+ *
+ * By default, results with errors (unexpected, EnvelopError, or GraphQLError) are not cached.
+ */
+export const defaultShouldCacheResult = (params) => {
+    if (params.result.errors) {
+        // eslint-disable-next-line no-console
+        console.warn('[useResponseCache] Failed to cache due to errors');
+        return false;
+    }
+    return true;
+};
+export const defaultGetDocumentStringFromContext = context => context[rawDocumentStringSymbol];
+export function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session = () => null, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = defaultBuildResponseCacheKey, getDocumentStringFromContext = defaultGetDocumentStringFromContext, 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 };
+    return {
+        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;
+            }
+            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,
+                    });
+                }
+            };
+        },
+        async onExecute(ctx) {
+            var _a;
+            const identifier = new Map();
+            const types = new Set();
+            const context = {
+                identifier,
+                types,
+                currentTtl: undefined,
+                ttlPerType,
+                ignoredTypesMap,
+                skip: false,
+            };
+            ctx.extendContext({
+                [contextSymbol]: context,
+            });
+            if (isMutation(ctx.args.document)) {
+                if (invalidateViaMutation === false) {
+                    return;
+                }
+                return {
+                    onExecuteDone({ result, setResult }) {
+                        if (isAsyncIterable(result)) {
+                            // eslint-disable-next-line no-console
+                            console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
+                            return;
+                        }
+                        cache.invalidate(context.identifier.values());
+                        if (includeExtensionMetadata) {
+                            setResult({
+                                ...result,
+                                extensions: {
+                                    ...result.extensions,
+                                    responseCache: {
+                                        invalidatedEntities: Array.from(context.identifier.values()),
+                                    },
+                                },
+                            });
+                        }
+                    },
+                };
+            }
+            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);
+                        }
+                        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 {
+                    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,
+                                    },
+                                },
+                            });
+                        }
+                    },
+                };
+            }
+            // 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;
+        },
+    };
+}
+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,38 +1,59 @@
 {
   "name": "@envelop/response-cache",
-  "version": "2.4.0-alpha-db79afa.0",
+  "version": "2.4.0-alpha-05dbec7.0",
   "sideEffects": false,
   "peerDependencies": {
-    "@envelop/core": "2.4.0-alpha-db79afa.0",
+    "@envelop/core": "2.4.0-alpha-05dbec7.0",
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
     "@graphql-tools/utils": "^8.6.1",
-    "fast-json-stable-stringify": "^2.1.0",
-    "lru-cache": "^6.0.0"
+    "lru-cache": "^6.0.0",
+    "fast-json-stable-stringify": "^2.1.0"
   },
   "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>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/{in-memory-cache.d.ts → typings/in-memory-cache.d.ts}

@@ -1,4 +1,4 @@
-import type { Cache } from './cache';
+import type { Cache } from './cache.js';
 export declare type BuildEntityId = (typename: string, id: number | string) => string;
 export declare type InMemoryCacheParameter = {
     /**
@@ -11,5 +11,5 @@ export declare type InMemoryCacheParameter = {
      */
     buildEntityId?: BuildEntityId;
 };
-export declare const createInMemoryCache: (params?: InMemoryCacheParameter | undefined) => Cache;
+export declare const createInMemoryCache: (params?: InMemoryCacheParameter) => Cache;
 export declare const defaultBuildEntityId: BuildEntityId;

package/typings/index.d.ts

@@ -0,0 +1,3 @@
+export * from './in-memory-cache.js';
+export * from './plugin.js';
+export * from './cache.js';

package/{plugin.d.ts → typings/plugin.d.ts}

@@ -1,6 +1,6 @@
 import { Plugin, Maybe, DefaultContext } from '@envelop/core';
 import { ExecutionArgs, ExecutionResult } from 'graphql';
-import type { Cache } from './cache';
+import type { Cache } from './cache.js';
 /**
  * Function for building the response cache key based on the input parameters
  */