@envelop/response-cache 3.0.0-alpha-868cc42.0 → 3.0.0-alpha-9dd2d31.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/{index.js → cjs/plugin.js}

@@ -1,158 +1,13 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const LRU = _interopDefault(require('lru-cache'));
-const core = require('@envelop/core');
-const utils = require('@graphql-tools/utils');
-const graphql = require('graphql');
-const jsonStableStringify = _interopDefault(require('fast-json-stable-stringify'));
-
-const createInMemoryCache = (params) => {
-    var _a;
-    const buildEntityId = (_a = params === null || params === void 0 ? void 0 : params.buildEntityId) !== null && _a !== void 0 ? _a : defaultBuildEntityId;
-    const cachedResponses = new LRU({
-        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);
-            }
-        },
-    };
-};
-const defaultBuildEntityId = (typename, id) => `${typename}:${id}`;
-
-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('');
-};
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useResponseCache = exports.defaultGetDocumentString = 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');
 /**
  * Default function used for building the response cache key.
@@ -160,13 +15,14 @@ const contextSymbol = Symbol('responseCache');
  */
 const defaultBuildResponseCacheKey = params => {
     var _a, _b, _c;
-    return hashSHA256([
+    return (0, hashSHA256_js_1.hashSHA256)([
         params.documentString,
         (_a = params.operationName) !== null && _a !== void 0 ? _a : '',
-        jsonStableStringify((_b = params.variableValues) !== null && _b !== void 0 ? _b : {}),
+        (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.
  *
@@ -183,16 +39,18 @@ const defaultShouldCacheResult = (params) => {
     }
     return true;
 };
+exports.defaultShouldCacheResult = defaultShouldCacheResult;
 const documentStringByDocument = new WeakMap();
 function defaultGetDocumentString(executionArgs) {
     let documentString = documentStringByDocument.get(executionArgs.document);
     if (!documentString) {
-        documentString = graphql.print(executionArgs.document);
+        documentString = (0, graphql_1.print)(executionArgs.document);
         documentStringByDocument.set(executionArgs.document, documentString);
     }
     return documentString;
 }
-function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session = () => null, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = defaultBuildResponseCacheKey, getDocumentString = defaultGetDocumentString, shouldCacheResult = defaultShouldCacheResult, 
+exports.defaultGetDocumentString = defaultGetDocumentString;
+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, getDocumentString = 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');
@@ -241,7 +99,7 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                 }
                 return {
                     onExecuteDone({ result, setResult }) {
-                        if (core.isAsyncIterable(result)) {
+                        if ((0, core_1.isAsyncIterable)(result)) {
                             // eslint-disable-next-line no-console
                             console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
                             return;
@@ -287,8 +145,8 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
                 }
             }
             if (ttlPerSchemaCoordinate) {
-                const typeInfo = new graphql.TypeInfo(ctx.args.schema);
-                graphql.visit(ctx.args.document, graphql.visitWithTypeInfo(typeInfo, {
+                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) {
@@ -304,7 +162,7 @@ includeExtensionMetadata = typeof process !== 'undefined' ? process.env['NODE_EN
             return {
                 onExecuteDone({ result, setResult }) {
                     var _a;
-                    if (core.isAsyncIterable(result)) {
+                    if ((0, core_1.isAsyncIterable)(result)) {
                         // eslint-disable-next-line no-console
                         console.warn('[useResponseCache] AsyncIterable returned from execute is currently unsupported.');
                         return;
@@ -349,6 +207,7 @@ 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';
 }
@@ -370,14 +229,14 @@ function runWith(input, callback) {
     }
 }
 function applyResponseCacheLogic(schema, idFieldNames) {
-    return utils.mapSchema(schema, {
-        [utils.MapperKind.OBJECT_FIELD](fieldConfig, fieldName, typename) {
+    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.defaultFieldResolver)(src, args, context, info);
+                        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) {
@@ -405,10 +264,3 @@ function applyResponseCacheLogic(schema, idFieldNames) {
         },
     });
 }
-
-exports.createInMemoryCache = createInMemoryCache;
-exports.defaultBuildEntityId = defaultBuildEntityId;
-exports.defaultBuildResponseCacheKey = defaultBuildResponseCacheKey;
-exports.defaultGetDocumentString = defaultGetDocumentString;
-exports.defaultShouldCacheResult = defaultShouldCacheResult;
-exports.useResponseCache = useResponseCache;

package/esm/cache.js

@@ -0,0 +1 @@
+export {};

package/esm/hashSHA256.js

@@ -0,0 +1,62 @@
+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) { }
+    }
+}
+export 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('');
+};

package/esm/in-memory-cache.js

@@ -0,0 +1,80 @@
+import LRU from 'lru-cache';
+export const createInMemoryCache = (params) => {
+    var _a;
+    const buildEntityId = (_a = params === null || params === void 0 ? void 0 : params.buildEntityId) !== null && _a !== void 0 ? _a : defaultBuildEntityId;
+    const cachedResponses = new LRU({
+        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);
+            }
+        },
+    };
+};
+export const defaultBuildEntityId = (typename, id) => `${typename}:${id}`;

package/esm/index.js

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

package/{index.mjs → esm/plugin.js}

@@ -1,158 +1,15 @@
-import LRU from 'lru-cache';
 import { isAsyncIterable } from '@envelop/core';
-import { mapSchema, MapperKind } from '@graphql-tools/utils';
-import { print, defaultFieldResolver, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
+import { MapperKind, mapSchema } from '@graphql-tools/utils';
+import { visit, TypeInfo, visitWithTypeInfo, defaultFieldResolver, print, } from 'graphql';
 import jsonStableStringify from 'fast-json-stable-stringify';
-
-const createInMemoryCache = (params) => {
-    var _a;
-    const buildEntityId = (_a = params === null || params === void 0 ? void 0 : params.buildEntityId) !== null && _a !== void 0 ? _a : defaultBuildEntityId;
-    const cachedResponses = new LRU({
-        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);
-            }
-        },
-    };
-};
-const defaultBuildEntityId = (typename, id) => `${typename}:${id}`;
-
-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('');
-};
-
+import { createInMemoryCache } from './in-memory-cache.js';
+import { hashSHA256 } from './hashSHA256.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.
  */
-const defaultBuildResponseCacheKey = params => {
+export const defaultBuildResponseCacheKey = params => {
     var _a, _b, _c;
     return hashSHA256([
         params.documentString,
@@ -169,7 +26,7 @@ const defaultBuildResponseCacheKey = params => {
  *
  * By default, results with errors (unexpected, EnvelopError, or GraphQLError) are not cached.
  */
-const defaultShouldCacheResult = (params) => {
+export const defaultShouldCacheResult = (params) => {
     if (params.result.errors) {
         // eslint-disable-next-line no-console
         console.warn('[useResponseCache] Failed to cache due to errors');
@@ -178,7 +35,7 @@ const defaultShouldCacheResult = (params) => {
     return true;
 };
 const documentStringByDocument = new WeakMap();
-function defaultGetDocumentString(executionArgs) {
+export function defaultGetDocumentString(executionArgs) {
     let documentString = documentStringByDocument.get(executionArgs.document);
     if (!documentString) {
         documentString = print(executionArgs.document);
@@ -186,7 +43,7 @@ function defaultGetDocumentString(executionArgs) {
     }
     return documentString;
 }
-function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session = () => null, enabled, ignoredTypes = [], ttlPerType = {}, ttlPerSchemaCoordinate = {}, idFields = ['id'], invalidateViaMutation = true, buildResponseCacheKey = defaultBuildResponseCacheKey, getDocumentString = defaultGetDocumentString, shouldCacheResult = defaultShouldCacheResult, 
+export function useResponseCache({ cache = createInMemoryCache(), ttl: globalTtl = Infinity, session = () => null, 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');
@@ -399,5 +256,3 @@ function applyResponseCacheLogic(schema, idFieldNames) {
         },
     });
 }
-
-export { createInMemoryCache, defaultBuildEntityId, defaultBuildResponseCacheKey, defaultGetDocumentString, defaultShouldCacheResult, useResponseCache };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@envelop/response-cache",
-  "version": "3.0.0-alpha-868cc42.0",
+  "version": "3.0.0-alpha-9dd2d31.0",
   "sideEffects": false,
   "peerDependencies": {
-    "@envelop/core": "^2.3.3",
+    "@envelop/core": "^2.4.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"
+    "@graphql-tools/utils": "^8.8.0",
+    "lru-cache": "^6.0.0",
+    "fast-json-stable-stringify": "^2.1.0"
   },
   "repository": {
     "type": "git",
@@ -18,21 +18,42 @@
   },
   "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 } 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
  */

package/index.d.ts

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