@envelop/response-cache 2.4.0-alpha-aca44e1.0 → 2.4.0-alpha-e9434aa.0

package/cjs/cache.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/hashSHA256.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashSHA256 = void 0;
+const webCrypto = globalThis.crypto;
+const sha256Browser = (bytes) => {
+    const hash = webCrypto.subtle.digest({ name: 'SHA-256' }, bytes);
+    return new Promise((resolve, reject) => {
+        Promise.resolve(hash)
+            .then(function (result) {
+            resolve(new Uint8Array(result));
+        })
+            .catch(function (error) {
+            reject(error);
+        });
+    });
+};
+let nodeCrypto;
+if (typeof window === 'undefined' && !webCrypto) {
+    // Indirect eval'd require/import to guarantee no side-effects in module scope
+    // (optimization for minifier)
+    try {
+        // eslint-disable-next-line no-new-func
+        nodeCrypto = Promise.resolve(new Function('require', 'return require("crypto")')(require));
+    }
+    catch (_error) {
+        try {
+            // eslint-disable-next-line no-new-func
+            nodeCrypto = new Function('return import("crypto")')();
+        }
+        catch (_error) { }
+    }
+}
+const hashSHA256 = async (text) => {
+    // Node.js support
+    if (nodeCrypto) {
+        return nodeCrypto.then(crypto => crypto.createHash('sha256').update(text).digest('hex'));
+    }
+    if (webCrypto) {
+        let buf;
+        if (typeof TextEncoder !== 'undefined') {
+            buf = new TextEncoder().encode(text);
+        }
+        else {
+            buf = new Uint8Array(text.length);
+            for (let i = 0, l = text.length; i < l; i++) {
+                // NOTE: We assume that the input GraphQL Query only uses UTF-8 at most
+                // since GraphQL mostly consists of ASCII, this is completely fine
+                buf[i] = text.charCodeAt(i);
+            }
+        }
+        const out = await sha256Browser(buf);
+        let hash = '';
+        for (let i = 0, l = out.length; i < l; i++) {
+            const hex = out[i].toString(16);
+            hash += '00'.slice(0, Math.max(0, 2 - hex.length)) + hex;
+        }
+        return hash;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        // eslint-disable-next-line no-console
+        console.warn('[@envelop/response-cache]: The Node Crypto and Web Crypto APIs are not available.\n' +
+            'This is an unexpected error. Please report it by filing a GitHub Issue.');
+    }
+    return Promise.resolve('');
+};
+exports.hashSHA256 = hashSHA256;

package/cjs/in-memory-cache.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultBuildEntityId = exports.createInMemoryCache = void 0;
+const tslib_1 = require("tslib");
+const lru_cache_1 = tslib_1.__importDefault(require("lru-cache"));
+const createInMemoryCache = (params) => {
+    var _a;
+    const buildEntityId = (_a = params === null || params === void 0 ? void 0 : params.buildEntityId) !== null && _a !== void 0 ? _a : exports.defaultBuildEntityId;
+    const cachedResponses = new lru_cache_1.default({
+        max: params === null || params === void 0 ? void 0 : params.max,
+        stale: false,
+        noDisposeOnSet: true,
+        dispose(responseId) {
+            purgeResponse(responseId, false);
+        },
+    });
+    const entityToResponseIds = new Map();
+    const responseIdToEntityIds = new Map();
+    function purgeResponse(responseId, shouldRemove = true) {
+        var _a;
+        const entityIds = responseIdToEntityIds.get(responseId);
+        // get entities related to the response
+        if (entityIds !== undefined) {
+            for (const entityId of entityIds) {
+                // remove the response mapping from the entity
+                (_a = entityToResponseIds.get(entityId)) === null || _a === void 0 ? void 0 : _a.delete(responseId);
+            }
+            // remove all the entity mappings from the response
+            responseIdToEntityIds.delete(responseId);
+        }
+        if (shouldRemove) {
+            // remove the response from the cache
+            cachedResponses.del(responseId);
+        }
+    }
+    function purgeEntity(entity) {
+        const responseIds = entityToResponseIds.get(entity);
+        if (responseIds !== undefined) {
+            for (const responseId of responseIds) {
+                purgeResponse(responseId);
+            }
+        }
+    }
+    return {
+        set(responseId, result, collectedEntities, ttl) {
+            cachedResponses.set(responseId, result, ttl);
+            const entityIds = new Set();
+            responseIdToEntityIds.set(responseId, entityIds);
+            for (const { typename, id } of collectedEntities) {
+                let operationIds = entityToResponseIds.get(typename);
+                if (operationIds == null) {
+                    operationIds = new Set();
+                    entityToResponseIds.set(typename, operationIds);
+                }
+                // typename => operation
+                operationIds.add(responseId);
+                // operation => typename
+                entityIds.add(typename);
+                if (id !== undefined) {
+                    const entityId = buildEntityId(typename, id);
+                    let responseIds = entityToResponseIds.get(entityId);
+                    if (responseIds == null) {
+                        responseIds = new Set();
+                        entityToResponseIds.set(entityId, responseIds);
+                    }
+                    // typename:id => operation
+                    responseIds.add(responseId);
+                    // operation => typename:id
+                    entityIds.add(entityId);
+                }
+            }
+        },
+        get(responseId) {
+            var _a;
+            return (_a = cachedResponses.get(responseId)) !== null && _a !== void 0 ? _a : null;
+        },
+        invalidate(entitiesToRemove) {
+            for (const { typename, id } of entitiesToRemove) {
+                purgeEntity(id != null ? buildEntityId(typename, id) : typename);
+            }
+        },
+    };
+};
+exports.createInMemoryCache = createInMemoryCache;
+const defaultBuildEntityId = (typename, id) => `${typename}:${id}`;
+exports.defaultBuildEntityId = defaultBuildEntityId;

package/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./in-memory-cache.js"), exports);
+tslib_1.__exportStar(require("./plugin.js"), exports);
+tslib_1.__exportStar(require("./cache.js"), exports);

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/plugin.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useResponseCache = exports.defaultGetDocumentStringFromContext = exports.defaultShouldCacheResult = exports.defaultBuildResponseCacheKey = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@envelop/core");
+const utils_1 = require("@graphql-tools/utils");
+const graphql_1 = require("graphql");
+const fast_json_stable_stringify_1 = tslib_1.__importDefault(require("fast-json-stable-stringify"));
+const in_memory_cache_js_1 = require("./in-memory-cache.js");
+const hashSHA256_js_1 = require("./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.
+ */
+const defaultBuildResponseCacheKey = params => {
+    var _a, _b, _c;
+    return (0, hashSHA256_js_1.hashSHA256)([
+        params.documentString,
+        (_a = params.operationName) !== null && _a !== void 0 ? _a : '',
+        (0, fast_json_stable_stringify_1.default)((_b = params.variableValues) !== null && _b !== void 0 ? _b : {}),
+        (_c = params.sessionId) !== null && _c !== void 0 ? _c : '',
+    ].join('|'));
+};
+exports.defaultBuildResponseCacheKey = defaultBuildResponseCacheKey;
+/**
+ * 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.
+ */
+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;
+};
+exports.defaultShouldCacheResult = defaultShouldCacheResult;
+const defaultGetDocumentStringFromContext = context => context[rawDocumentStringSymbol];
+exports.defaultGetDocumentStringFromContext = defaultGetDocumentStringFromContext;
+function useResponseCache({ cache = (0, in_memory_cache_js_1.createInMemoryCache)(), ttl: globalTtl = Infinity, session = () => null, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = exports.defaultBuildResponseCacheKey, getDocumentStringFromContext = exports.defaultGetDocumentStringFromContext, 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 };
+    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 ((0, core_1.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 graphql_1.TypeInfo(ctx.args.schema);
+                    (0, graphql_1.visit)(ctx.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);
+                                }
+                            }
+                        },
+                    }));
+                }
+                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) {
+                            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;
+        },
+    };
+}
+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/cache.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/hashSHA256.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashSHA256 = void 0;
+const webCrypto = globalThis.crypto;
+const sha256Browser = (bytes) => {
+    const hash = webCrypto.subtle.digest({ name: 'SHA-256' }, bytes);
+    return new Promise((resolve, reject) => {
+        Promise.resolve(hash)
+            .then(function (result) {
+            resolve(new Uint8Array(result));
+        })
+            .catch(function (error) {
+            reject(error);
+        });
+    });
+};
+let nodeCrypto;
+if (typeof window === 'undefined' && !webCrypto) {
+    // Indirect eval'd require/import to guarantee no side-effects in module scope
+    // (optimization for minifier)
+    try {
+        // eslint-disable-next-line no-new-func
+        nodeCrypto = Promise.resolve(new Function('require', 'return require("crypto")')(require));
+    }
+    catch (_error) {
+        try {
+            // eslint-disable-next-line no-new-func
+            nodeCrypto = new Function('return import("crypto")')();
+        }
+        catch (_error) { }
+    }
+}
+const hashSHA256 = async (text) => {
+    // Node.js support
+    if (nodeCrypto) {
+        return nodeCrypto.then(crypto => crypto.createHash('sha256').update(text).digest('hex'));
+    }
+    if (webCrypto) {
+        let buf;
+        if (typeof TextEncoder !== 'undefined') {
+            buf = new TextEncoder().encode(text);
+        }
+        else {
+            buf = new Uint8Array(text.length);
+            for (let i = 0, l = text.length; i < l; i++) {
+                // NOTE: We assume that the input GraphQL Query only uses UTF-8 at most
+                // since GraphQL mostly consists of ASCII, this is completely fine
+                buf[i] = text.charCodeAt(i);
+            }
+        }
+        const out = await sha256Browser(buf);
+        let hash = '';
+        for (let i = 0, l = out.length; i < l; i++) {
+            const hex = out[i].toString(16);
+            hash += '00'.slice(0, Math.max(0, 2 - hex.length)) + hex;
+        }
+        return hash;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        // eslint-disable-next-line no-console
+        console.warn('[@envelop/response-cache]: The Node Crypto and Web Crypto APIs are not available.\n' +
+            'This is an unexpected error. Please report it by filing a GitHub Issue.');
+    }
+    return Promise.resolve('');
+};
+exports.hashSHA256 = hashSHA256;

package/esm/in-memory-cache.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultBuildEntityId = exports.createInMemoryCache = void 0;
+const lru_cache_1 = __importDefault(require("lru-cache"));
+const createInMemoryCache = (params) => {
+    var _a;
+    const buildEntityId = (_a = params === null || params === void 0 ? void 0 : params.buildEntityId) !== null && _a !== void 0 ? _a : exports.defaultBuildEntityId;
+    const cachedResponses = new lru_cache_1.default({
+        max: params === null || params === void 0 ? void 0 : params.max,
+        stale: false,
+        noDisposeOnSet: true,
+        dispose(responseId) {
+            purgeResponse(responseId, false);
+        },
+    });
+    const entityToResponseIds = new Map();
+    const responseIdToEntityIds = new Map();
+    function purgeResponse(responseId, shouldRemove = true) {
+        var _a;
+        const entityIds = responseIdToEntityIds.get(responseId);
+        // get entities related to the response
+        if (entityIds !== undefined) {
+            for (const entityId of entityIds) {
+                // remove the response mapping from the entity
+                (_a = entityToResponseIds.get(entityId)) === null || _a === void 0 ? void 0 : _a.delete(responseId);
+            }
+            // remove all the entity mappings from the response
+            responseIdToEntityIds.delete(responseId);
+        }
+        if (shouldRemove) {
+            // remove the response from the cache
+            cachedResponses.del(responseId);
+        }
+    }
+    function purgeEntity(entity) {
+        const responseIds = entityToResponseIds.get(entity);
+        if (responseIds !== undefined) {
+            for (const responseId of responseIds) {
+                purgeResponse(responseId);
+            }
+        }
+    }
+    return {
+        set(responseId, result, collectedEntities, ttl) {
+            cachedResponses.set(responseId, result, ttl);
+            const entityIds = new Set();
+            responseIdToEntityIds.set(responseId, entityIds);
+            for (const { typename, id } of collectedEntities) {
+                let operationIds = entityToResponseIds.get(typename);
+                if (operationIds == null) {
+                    operationIds = new Set();
+                    entityToResponseIds.set(typename, operationIds);
+                }
+                // typename => operation
+                operationIds.add(responseId);
+                // operation => typename
+                entityIds.add(typename);
+                if (id !== undefined) {
+                    const entityId = buildEntityId(typename, id);
+                    let responseIds = entityToResponseIds.get(entityId);
+                    if (responseIds == null) {
+                        responseIds = new Set();
+                        entityToResponseIds.set(entityId, responseIds);
+                    }
+                    // typename:id => operation
+                    responseIds.add(responseId);
+                    // operation => typename:id
+                    entityIds.add(entityId);
+                }
+            }
+        },
+        get(responseId) {
+            var _a;
+            return (_a = cachedResponses.get(responseId)) !== null && _a !== void 0 ? _a : null;
+        },
+        invalidate(entitiesToRemove) {
+            for (const { typename, id } of entitiesToRemove) {
+                purgeEntity(id != null ? buildEntityId(typename, id) : typename);
+            }
+        },
+    };
+};
+exports.createInMemoryCache = createInMemoryCache;
+const defaultBuildEntityId = (typename, id) => `${typename}:${id}`;
+exports.defaultBuildEntityId = defaultBuildEntityId;

package/esm/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./in-memory-cache.js"), exports);
+__exportStar(require("./plugin.js"), exports);
+__exportStar(require("./cache.js"), exports);