@graphql-box/cache-manager 4.1.4 → 5.0.0

package/lib/main/main/index.js

@@ -1,1090 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-require("core-js/modules/es.promise.js");
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));
-
-var _unset2 = _interopRequireDefault(require("lodash/unset"));
-
-var _set2 = _interopRequireDefault(require("lodash/set"));
-
-var _isUndefined2 = _interopRequireDefault(require("lodash/isUndefined"));
-
-var _isPlainObject2 = _interopRequireDefault(require("lodash/isPlainObject"));
-
-var _isObjectLike2 = _interopRequireDefault(require("lodash/isObjectLike"));
-
-var _isArray2 = _interopRequireDefault(require("lodash/isArray"));
-
-var _get2 = _interopRequireDefault(require("lodash/get"));
-
-var _cloneDeep2 = _interopRequireDefault(require("lodash/cloneDeep"));
-
-var _assign2 = _interopRequireDefault(require("lodash/assign"));
-
-var _core = require("@graphql-box/core");
-
-var _helpers = require("@graphql-box/helpers");
-
-var _cacheability2 = _interopRequireDefault(require("cacheability"));
-
-var _graphql = require("graphql");
-
-var _consts = require("../consts");
-
-var _debug = require("../debug");
-
-var _areOnlyPopulatedFieldsTypeIdKeys = _interopRequireDefault(require("../helpers/areOnlyPopulatedFieldsTypeIdKeys"));
-
-var _deriveOpCacheability = _interopRequireDefault(require("../helpers/deriveOpCacheability"));
-
-var _filterOutPropsWithArgsOrDirectives = _interopRequireDefault(require("../helpers/filterOutPropsWithArgsOrDirectives"));
-
-var _filterQuery = _interopRequireDefault(require("../helpers/filterQuery"));
-
-var _isLastResponseChunk = _interopRequireDefault(require("../helpers/isLastResponseChunk"));
-
-var _isNotLastResponseChunk = _interopRequireDefault(require("../helpers/isNotLastResponseChunk"));
-
-var _isNotResponseChunk = _interopRequireDefault(require("../helpers/isNotResponseChunk"));
-
-var _mergeResponseDataSets = _interopRequireDefault(require("../helpers/mergeResponseDataSets"));
-
-var _normalizePatchResponseData = _interopRequireDefault(require("../helpers/normalizePatchResponseData"));
-
-var _validTypeIDValue = require("../helpers/validTypeIDValue");
-
-var _dec, _dec2, _dec3, _class;
-
-let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCacheEntry)(), _dec3 = (0, _debug.logPartialCompiled)(), (_class = class CacheManager {
-  static _countFieldPathChecklist(fieldPathChecklist) {
-    const fieldCount = {
-      missing: 0,
-      total: 0
-    };
-    fieldPathChecklist.forEach(checklistValues => {
-      fieldCount.total += checklistValues.length;
-      const missing = checklistValues.filter(({
-        hasData
-      }) => !hasData);
-      fieldCount.missing += missing.length;
-    });
-    return fieldCount;
-  }
-
-  static _getFieldDataFromAncestor(ancestorFieldData, propNameOrIndex) {
-    return (0, _isObjectLike2.default)(ancestorFieldData) ? (0, _cloneDeep2.default)(ancestorFieldData[propNameOrIndex]) : undefined;
-  }
-
-  static _getOperationCacheControl(cacheMetadata, operation) {
-    const defaultCacheControl = _consts.HEADER_NO_CACHE;
-
-    if (!cacheMetadata) {
-      return defaultCacheControl;
-    }
-
-    const cacheability = cacheMetadata.get(operation);
-    return cacheability ? cacheability.printCacheControl() : defaultCacheControl;
-  }
-
-  static _isNodeEntity(fieldTypeInfo) {
-    if (!fieldTypeInfo) {
-      return false;
-    }
-
-    const {
-      isEntity,
-      possibleTypes
-    } = fieldTypeInfo;
-    return isEntity || possibleTypes.some(type => !!type.isEntity);
-  }
-
-  static _isNodeRequestFieldPath(fieldTypeInfo) {
-    return !!fieldTypeInfo && (this._isNodeEntity(fieldTypeInfo) || fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives);
-  }
-
-  static _isValid(cacheability) {
-    const noCache = (0, _get2.default)(cacheability, [_consts.METADATA, _consts.CACHE_CONTROL, _consts.NO_CACHE], false);
-    return !noCache && cacheability.checkTTL();
-  }
-
-  static _mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse) {
-    if (!partialQueryResponse) {
-      return cacheMetadata;
-    }
-
-    return new Map([...partialQueryResponse.cacheMetadata, ...cacheMetadata]);
-  }
-
-  static _setCachedData(requestData, {
-    data
-  }, propNameOrIndex) {
-    if (!(0, _isObjectLike2.default)(data) && !(0, _isUndefined2.default)(data)) {
-      requestData[propNameOrIndex] = data;
-    } else if ((0, _isObjectLike2.default)(data)) {
-      const objectLikeData = data;
-      requestData[propNameOrIndex] = (0, _isArray2.default)(objectLikeData) ? [] : {};
-    }
-  }
-
-  static _setCachedResponseData(cachedFieldData, {
-    cacheMetadata,
-    data,
-    fieldPathChecklist
-  }, {
-    propNameOrIndex,
-    requestFieldPath
-  }, typeNamesAndKind, _options, {
-    operation
-  }) {
-    CacheManager._setCacheMetadata(cacheMetadata, cachedFieldData.cacheability, requestFieldPath, operation);
-
-    CacheManager._setFieldPathChecklist(fieldPathChecklist, cachedFieldData, requestFieldPath, typeNamesAndKind);
-
-    CacheManager._setCachedData(data, cachedFieldData, propNameOrIndex);
-  }
-
-  static _setCacheMetadata(cacheMetadata, cacheability, requestFieldPath, operation) {
-    if (!cacheability) {
-      return;
-    }
-
-    cacheMetadata.set(requestFieldPath, cacheability);
-    const operationCacheability = cacheMetadata.get(operation);
-
-    if (!operationCacheability || operationCacheability.metadata.ttl > cacheability.metadata.ttl) {
-      cacheMetadata.set(operation, cacheability);
-    }
-  }
-
-  static _setFieldPathChecklist(fieldPathChecklist, {
-    data
-  }, requestFieldPath, {
-    dataTypeName,
-    fieldTypeName,
-    fragmentKind,
-    fragmentName
-  }) {
-    if ((0, _isUndefined2.default)(fieldTypeName) || fragmentKind === _helpers.FRAGMENT_SPREAD) {
-      if (fieldPathChecklist.has(requestFieldPath)) {
-        return;
-      }
-
-      fieldPathChecklist.set(requestFieldPath, [{
-        fragmentKind,
-        fragmentName,
-        hasData: !(0, _isUndefined2.default)(data)
-      }]);
-      return;
-    }
-
-    if (dataTypeName !== fieldTypeName) {
-      return;
-    }
-
-    const entry = fieldPathChecklist.get(requestFieldPath);
-    const checklistValues = entry ? entry : [];
-
-    if (checklistValues.some(({
-      typeName
-    }) => typeName === dataTypeName)) {
-      return;
-    }
-
-    fieldPathChecklist.set(requestFieldPath, [...checklistValues, {
-      fragmentKind,
-      fragmentName,
-      hasData: !(0, _isUndefined2.default)(data),
-      typeName: dataTypeName
-    }]);
-  }
-
-  constructor(options) {
-    var _options$typeIDKey;
-
-    (0, _defineProperty2.default)(this, "_cache", void 0);
-    (0, _defineProperty2.default)(this, "_cascadeCacheControl", void 0);
-    (0, _defineProperty2.default)(this, "_fallbackOperationCacheability", void 0);
-    (0, _defineProperty2.default)(this, "_partialQueryResponses", new Map());
-    (0, _defineProperty2.default)(this, "_responseChunksAwaitingCaching", new Map());
-    (0, _defineProperty2.default)(this, "_typeCacheDirectives", void 0);
-    (0, _defineProperty2.default)(this, "_typeIDKey", void 0);
-    const errors = [];
-
-    if (!options.cache) {
-      errors.push(new TypeError("@graphql-box/cache-manager expected options.cache."));
-    }
-
-    if (!!options.typeCacheDirectives && !(0, _isPlainObject2.default)(options.typeCacheDirectives)) {
-      const message = "@graphql-box/cache-manager expected options.typeCacheDirectives to be a plain object.";
-      errors.push(new TypeError(message));
-    }
-
-    if (errors.length) {
-      throw errors;
-    }
-
-    this._cache = options.cache;
-    this._cascadeCacheControl = options.cascadeCacheControl || false;
-    this._fallbackOperationCacheability = options.fallbackOperationCacheability || _consts.NO_CACHE;
-    this._typeCacheDirectives = options.typeCacheDirectives || {};
-    this._typeIDKey = (_options$typeIDKey = options.typeIDKey) !== null && _options$typeIDKey !== void 0 ? _options$typeIDKey : _core.DEFAULT_TYPE_ID_KEY;
-  }
-
-  get cache() {
-    return this._cache;
-  }
-
-  async analyzeQuery(requestData, options, context) {
-    const {
-      ast,
-      hash
-    } = requestData;
-
-    if (!ast) {
-      return Promise.reject(new TypeError("@graphql-box/cache-manager expected an AST."));
-    }
-
-    const cacheManagerContext = { ...context,
-      fragmentDefinitions: (0, _helpers.getFragmentDefinitions)(ast),
-      typeIDKey: this._typeIDKey
-    };
-    const cachedResponseData = await this._retrieveCachedResponseData(requestData, options, cacheManagerContext);
-    const {
-      cacheMetadata,
-      data,
-      fieldCount
-    } = cachedResponseData;
-
-    if (fieldCount.missing === fieldCount.total || (0, _areOnlyPopulatedFieldsTypeIdKeys.default)(data, this._typeIDKey)) {
-      return {
-        updated: requestData
-      };
-    }
-
-    if (!fieldCount.missing) {
-      const dataCaching = this._setQueryResponseCacheEntry(hash, {
-        cacheMetadata,
-        data
-      }, options, cacheManagerContext);
-
-      if (options.awaitDataCaching) {
-        await dataCaching;
-      }
-
-      return {
-        response: {
-          cacheMetadata,
-          data
-        }
-      };
-    }
-
-    const filteredAST = (0, _filterQuery.default)(requestData, cachedResponseData, cacheManagerContext);
-    const filteredRequest = (0, _graphql.print)(filteredAST);
-    const {
-      fragmentDefinitions,
-      typeIDKey,
-      ...rest
-    } = cacheManagerContext;
-    (0, _assign2.default)(context, { ...rest,
-      filteredRequest
-    });
-
-    this._setPartialQueryResponse(hash, {
-      cacheMetadata,
-      data
-    }, options, context);
-
-    return {
-      updated: {
-        ast: filteredAST,
-        hash: (0, _helpers.hashRequest)(filteredRequest),
-        request: filteredRequest
-      }
-    };
-  }
-
-  async cacheQuery(requestData, updatedRequestData, rawResponseData, options, context) {
-    const cacheManagerContext = { ...context,
-      fragmentDefinitions: (0, _helpers.getFragmentDefinitions)((updatedRequestData !== null && updatedRequestData !== void 0 ? updatedRequestData : requestData).ast),
-      typeIDKey: this._typeIDKey
-    };
-    return this._cacheResponse(requestData, updatedRequestData, rawResponseData, options, cacheManagerContext);
-  }
-
-  async cacheResponse(requestData, rawResponseData, options, context) {
-    const cacheManagerContext = { ...context,
-      fragmentDefinitions: (0, _helpers.getFragmentDefinitions)(requestData.ast),
-      typeIDKey: this._typeIDKey
-    };
-    return this._cacheResponse(requestData, undefined, rawResponseData, options, cacheManagerContext);
-  }
-
-  async checkCacheEntry(cacheType, hash, options, context) {
-    return this._checkCacheEntry(cacheType, hash, options, context);
-  }
-
-  async checkQueryResponseCacheEntry(hash, options, context) {
-    const result = await this._checkCacheEntry(_core.QUERY_RESPONSES, hash, options, context);
-
-    if (!result) {
-      return false;
-    }
-
-    const {
-      cacheMetadata,
-      data
-    } = result.entry;
-    return {
-      cacheMetadata: (0, _helpers.rehydrateCacheMetadata)(cacheMetadata),
-      data
-    };
-  }
-
-  deletePartialQueryResponse(hash) {
-    this._partialQueryResponses.delete(hash);
-  }
-
-  async setQueryResponseCacheEntry(requestData, responseData, options, context) {
-    return this._setQueryResponseCacheEntry(requestData.hash, responseData, options, context);
-  }
-
-  async _analyzeFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
-    if ((0, _helpers.hasChildFields)(fieldNode, {
-      fragmentDefinitions: context.fragmentDefinitions
-    })) {
-      await this._analyzeParentFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
-    } else {
-      await this._analyzeLeafFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
-    }
-  }
-
-  async _analyzeLeafFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
-    const keysAndPaths = (0, _helpers.buildFieldKeysAndPaths)(fieldNode, cachedAncestorFieldData, context);
-    const {
-      hashedRequestFieldCacheKey,
-      propNameOrIndex,
-      requestFieldCacheKey,
-      requestFieldPath
-    } = keysAndPaths;
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    const {
-      entityData,
-      fragmentKind,
-      fragmentName,
-      requestFieldPathData,
-      typeName
-    } = cachedAncestorFieldData;
-    const typeNamesAndKind = {
-      dataTypeName: (entityData === null || entityData === void 0 ? void 0 : entityData.__typename) || (requestFieldPathData === null || requestFieldPathData === void 0 ? void 0 : requestFieldPathData.__typename),
-      fieldTypeName: typeName,
-      fragmentKind,
-      fragmentName
-    };
-
-    if (CacheManager._isNodeRequestFieldPath(fieldTypeInfo)) {
-      const {
-        cacheability,
-        entry
-      } = await this._retrieveCachedRequestFieldPathData(hashedRequestFieldCacheKey, requestFieldCacheKey, options, context);
-
-      CacheManager._setCachedResponseData({
-        cacheability,
-        data: entry
-      }, cachedResponseData, keysAndPaths, typeNamesAndKind, options, context);
-    } else {
-      const cachedFieldData = CacheManager._getFieldDataFromAncestor(entityData, propNameOrIndex) || CacheManager._getFieldDataFromAncestor(requestFieldPathData, propNameOrIndex);
-
-      CacheManager._setFieldPathChecklist(cachedResponseData.fieldPathChecklist, {
-        data: cachedFieldData
-      }, requestFieldPath, typeNamesAndKind);
-
-      CacheManager._setCachedData(cachedResponseData.data, {
-        data: cachedFieldData
-      }, propNameOrIndex);
-    }
-  }
-
-  async _analyzeParentFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
-    const keysAndPaths = (0, _helpers.buildFieldKeysAndPaths)(fieldNode, cachedAncestorFieldData, context);
-    const {
-      propNameOrIndex,
-      requestFieldCacheKey,
-      requestFieldPath
-    } = keysAndPaths;
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    const {
-      cacheability,
-      data,
-      entityData,
-      requestFieldPathData
-    } = await this._retrieveCachedParentNodeData(cachedAncestorFieldData, keysAndPaths, fieldTypeInfo, options, context);
-    const {
-      fragmentKind,
-      fragmentName,
-      typeName
-    } = cachedAncestorFieldData;
-
-    CacheManager._setCachedResponseData({
-      cacheability,
-      data
-    }, cachedResponseData, keysAndPaths, {
-      dataTypeName: (0, _get2.default)(data, _core.TYPE_NAME_KEY),
-      fieldTypeName: typeName,
-      fragmentKind,
-      fragmentName
-    }, options, context);
-
-    if (!(0, _isObjectLike2.default)(data)) {
-      return;
-    }
-
-    const objectLikeData = data;
-    const promises = [];
-    (0, _helpers.iterateChildFields)(fieldNode, objectLikeData, context.fragmentDefinitions, (childField, childTypeName, childFragmentKind, childFragmentName, childIndex) => {
-      promises.push(this._analyzeFieldNode(childField, {
-        cacheability,
-        entityData,
-        fragmentKind: childFragmentKind,
-        fragmentName: childFragmentName,
-        index: childIndex,
-        requestFieldCacheKey,
-        requestFieldPath,
-        requestFieldPathData,
-        typeName: childTypeName
-      }, { ...cachedResponseData,
-        data: cachedResponseData.data[propNameOrIndex]
-      }, options, context));
-    });
-    await Promise.all(promises);
-  }
-
-  _buildCacheMetadata({
-    ast
-  }, {
-    data,
-    ...otherProps
-  }, options, context) {
-    const cacheMetadata = this._createCacheMetadata({
-      data,
-      ...otherProps
-    }, context);
-
-    const queryNode = (0, _helpers.getOperationDefinitions)(ast, context.operation)[0];
-    const fieldsAndTypeNames = (0, _helpers.getChildFields)(queryNode);
-
-    if (!fieldsAndTypeNames) {
-      return cacheMetadata;
-    }
-
-    fieldsAndTypeNames.forEach(({
-      fieldNode
-    }) => this._setFieldCacheability(fieldNode, {
-      requestFieldPath: context.operation
-    }, {
-      cacheMetadata,
-      data
-    }, options, context));
-    return cacheMetadata;
-  }
-
-  async _cacheResponse(requestData, updatedRequestData, rawResponseData, options, context) {
-    const normalizedResponseData = (0, _normalizePatchResponseData.default)(rawResponseData, context);
-    let responseDataForCaching = normalizedResponseData;
-
-    if ((0, _isNotLastResponseChunk.default)(rawResponseData, context)) {
-      this._setResponseChunksAwaitingCaching(normalizedResponseData, context);
-
-      responseDataForCaching = undefined;
-    }
-
-    if ((0, _isLastResponseChunk.default)(rawResponseData, context)) {
-      responseDataForCaching = this._retrieveResponseDataForCaching(normalizedResponseData, context);
-    }
-
-    const dataCaching = [];
-
-    if (responseDataForCaching) {
-      const {
-        data
-      } = responseDataForCaching;
-
-      const cacheMetadata = this._buildCacheMetadata(requestData, responseDataForCaching, options, context);
-
-      dataCaching.push(this._setEntityAndRequestFieldPathCacheEntries(requestData, {
-        cacheMetadata,
-        entityData: (0, _cloneDeep2.default)(data),
-        requestFieldPathData: (0, _cloneDeep2.default)(data)
-      }, options, context));
-      let queryCacheMetadata;
-      let queryData;
-
-      if (context.operation === _core.QUERY) {
-        let partialQueryResponse;
-
-        if (context.queryFiltered && updatedRequestData) {
-          dataCaching.push(this._setQueryResponseCacheEntry(updatedRequestData.hash, {
-            cacheMetadata,
-            data
-          }, options, context));
-          partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
-        }
-
-        queryCacheMetadata = CacheManager._mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse);
-        queryData = this._mergeResponseData(data, partialQueryResponse);
-        dataCaching.push(this._setQueryResponseCacheEntry(requestData.hash, {
-          cacheMetadata: queryCacheMetadata,
-          data: queryData
-        }, options, context));
-      }
-
-      if (options.awaitDataCaching) {
-        await Promise.all(dataCaching);
-      }
-
-      if ((0, _isNotResponseChunk.default)(normalizedResponseData, context) && queryCacheMetadata && queryData) {
-        return {
-          cacheMetadata: queryCacheMetadata,
-          data: queryData
-        };
-      }
-    }
-
-    const {
-      data,
-      hasNext,
-      paths
-    } = normalizedResponseData;
-    return {
-      cacheMetadata: this._buildCacheMetadata(requestData, normalizedResponseData, options, context),
-      data,
-      hasNext,
-      paths
-    };
-  }
-
-  async _checkCacheEntry(cacheType, hash, options, context) {
-    try {
-      const cacheability = await this._hasCacheEntry(cacheType, hash);
-
-      if (!cacheability || !CacheManager._isValid(cacheability)) {
-        return false;
-      }
-
-      const entry = await this._getCacheEntry(cacheType, hash, options, context);
-
-      if ((0, _isUndefined2.default)(entry)) {
-        return false;
-      }
-
-      return {
-        cacheability,
-        entry
-      };
-    } catch (error) {
-      return false;
-    }
-  }
-
-  _createCacheMetadata({
-    _cacheMetadata,
-    headers
-  }, {
-    operation
-  }) {
-    const cacheMetadata = new Map();
-    const cacheability = (0, _deriveOpCacheability.default)({
-      _cacheMetadata,
-      fallback: this._fallbackOperationCacheability,
-      headers
-    });
-    cacheMetadata.set(operation, cacheability);
-
-    if (_cacheMetadata) {
-      (0, _helpers.rehydrateCacheMetadata)(_cacheMetadata, cacheMetadata);
-    }
-
-    return cacheMetadata;
-  }
-
-  async _getCacheEntry(cacheType, hash, _options, _context) {
-    try {
-      return await this._cache.get(`${cacheType}::${hash}`);
-    } catch (errors) {
-      return Promise.reject(errors);
-    }
-  }
-
-  _getPartialQueryResponse(hash) {
-    const partialQueryResponse = this._partialQueryResponses.get(hash);
-
-    this._partialQueryResponses.delete(hash);
-
-    return partialQueryResponse;
-  }
-
-  async _hasCacheEntry(cacheType, hash) {
-    try {
-      return await this._cache.has(`${cacheType}::${hash}`);
-    } catch (error) {
-      return false;
-    }
-  }
-
-  _isFieldEntity(fieldData, {
-    isEntity,
-    possibleTypes
-  }) {
-    if (!(0, _get2.default)(fieldData, this._typeIDKey, null)) {
-      return false;
-    }
-
-    if (isEntity) {
-      return true;
-    }
-
-    if (!possibleTypes.length) {
-      return false;
-    }
-
-    return possibleTypes.some(type => type.typeName === fieldData.__typename);
-  }
-
-  _mergeObjects(obj, src) {
-    return (0, _helpers.mergeObjects)(obj, src, (_key, val) => {
-      return (0, _isPlainObject2.default)(val) && val[this._typeIDKey] ? val[this._typeIDKey] : undefined;
-    });
-  }
-
-  _mergeResponseData(responseData, partialQueryResponse) {
-    if (!partialQueryResponse) {
-      return responseData;
-    }
-
-    return this._mergeObjects(partialQueryResponse.data, responseData);
-  }
-
-  async _parseEntityAndRequestFieldPathCacheEntryData(field, ancestorKeysAndPaths, {
-    cacheMetadata,
-    entityData,
-    requestFieldPathData
-  }, options, context) {
-    const keysAndPaths = (0, _helpers.buildFieldKeysAndPaths)(field, ancestorKeysAndPaths, context);
-    const {
-      requestFieldCacheKey,
-      requestFieldPath,
-      responseDataPath
-    } = keysAndPaths;
-    const fieldData = (0, _get2.default)(requestFieldPathData, responseDataPath);
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-
-    if (!(0, _isObjectLike2.default)(fieldData) && !(fieldTypeInfo !== null && fieldTypeInfo !== void 0 && fieldTypeInfo.hasDirectives)) {
-      return;
-    }
-
-    if ((0, _isObjectLike2.default)(fieldData)) {
-      const promises = [];
-      (0, _helpers.iterateChildFields)(field, fieldData, context.fragmentDefinitions, (childField, _typeName, _fragmentKind, _fragmentName, childIndex) => {
-        promises.push(this._parseEntityAndRequestFieldPathCacheEntryData(childField, {
-          index: childIndex,
-          requestFieldCacheKey,
-          requestFieldPath,
-          responseDataPath
-        }, {
-          cacheMetadata,
-          entityData,
-          requestFieldPathData
-        }, options, context));
-      });
-      await Promise.all(promises);
-    }
-
-    await this._setEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
-      cacheMetadata,
-      entityData,
-      requestFieldPathData
-    }, options, context);
-  }
-
-  async _retrieveCachedEntityData(validTypeIDValue, {
-    possibleTypes,
-    typeName
-  }, options, context) {
-    const typeNames = [...possibleTypes.map(type => type.typeName), typeName];
-    const checkResults = await Promise.all(typeNames.map(name => this._checkCacheEntry(_core.DATA_ENTITIES, `${name}::${validTypeIDValue}`, options, context)));
-    const validResults = checkResults.filter(result => !!result);
-    let validResult;
-
-    if (validResults.length === 1) {
-      validResult = validResults[0];
-    } else if (validResults.length > 1) {
-      validResults.sort(({
-        cacheability: a
-      }, {
-        cacheability: b
-      }) => a.metadata.ttl - b.metadata.ttl);
-      validResult = {
-        cacheability: validResults[0].cacheability,
-        entry: validResults.reduce((obj, {
-          entry
-        }) => this._mergeObjects(obj, entry), {})
-      };
-    }
-
-    return validResult || {};
-  }
-
-  async _retrieveCachedParentNodeData({
-    entityData: ancestorEntityData,
-    requestFieldPathData: ancestorRequestFieldPathData
-  }, {
-    hashedRequestFieldCacheKey,
-    propNameOrIndex,
-    requestFieldCacheKey
-  }, fieldTypeInfo, options, context) {
-    var _entityData;
-
-    let entityData = CacheManager._getFieldDataFromAncestor(ancestorEntityData, propNameOrIndex);
-
-    let requestFieldPathData = CacheManager._getFieldDataFromAncestor(ancestorRequestFieldPathData, propNameOrIndex);
-
-    let cacheability;
-
-    if (CacheManager._isNodeRequestFieldPath(fieldTypeInfo)) {
-      const {
-        cacheability: entryCacheability,
-        entry
-      } = await this._retrieveCachedRequestFieldPathData(hashedRequestFieldCacheKey, requestFieldCacheKey, options, context);
-
-      if (entry) {
-        requestFieldPathData = this._mergeObjects(requestFieldPathData, entry);
-      }
-
-      if (entryCacheability) {
-        cacheability = entryCacheability;
-      }
-    }
-
-    const validTypeIDValue = (0, _validTypeIDValue.getValidTypeIDValue)(requestFieldPathData, fieldTypeInfo, this._typeIDKey);
-
-    if (CacheManager._isNodeEntity(fieldTypeInfo) && validTypeIDValue) {
-      var _cacheability;
-
-      const {
-        cacheability: entryCacheability,
-        entry
-      } = await this._retrieveCachedEntityData(validTypeIDValue, fieldTypeInfo, options, context);
-
-      if (entry) {
-        entityData = this._mergeObjects(entityData, entry);
-      }
-
-      if (entryCacheability && (!cacheability || entryCacheability.metadata.ttl > ((_cacheability = cacheability) === null || _cacheability === void 0 ? void 0 : _cacheability.metadata.ttl))) {
-        cacheability = entryCacheability;
-      }
-    }
-
-    const data = !(0, _isUndefined2.default)(requestFieldPathData) || !(0, _isUndefined2.default)(entityData) ? this._mergeObjects(requestFieldPathData, entityData) : (_entityData = entityData) !== null && _entityData !== void 0 ? _entityData : requestFieldPathData;
-    return {
-      cacheability,
-      data,
-      entityData,
-      requestFieldPathData
-    };
-  }
-
-  async _retrieveCachedRequestFieldPathData(hash, requestFieldCacheKey, options, context) {
-    return this._checkCacheEntry(_core.REQUEST_FIELD_PATHS, hash, options, { ...context,
-      requestFieldCacheKey
-    }) || {};
-  }
-
-  async _retrieveCachedResponseData({
-    ast
-  }, options, context) {
-    const cachedResponseData = {
-      cacheMetadata: new Map(),
-      data: {},
-      fieldCount: {
-        missing: 0,
-        total: 0
-      },
-      fieldPathChecklist: new Map()
-    };
-    const queryNode = (0, _helpers.getOperationDefinitions)(ast, context.operation)[0];
-    const fieldsAndTypeNames = (0, _helpers.getChildFields)(queryNode);
-
-    if (!fieldsAndTypeNames) {
-      return cachedResponseData;
-    }
-
-    await Promise.all(fieldsAndTypeNames.map(({
-      fieldNode
-    }) => this._analyzeFieldNode(fieldNode, {
-      requestFieldPath: context.operation
-    }, cachedResponseData, options, context)));
-    cachedResponseData.fieldCount = CacheManager._countFieldPathChecklist(cachedResponseData.fieldPathChecklist);
-    return cachedResponseData;
-  }
-
-  _retrieveResponseDataForCaching(normalizedResponseData, context) {
-    const responseChunks = this._responseChunksAwaitingCaching.get(context.requestID);
-
-    this._responseChunksAwaitingCaching.delete(context.requestID);
-
-    return (0, _mergeResponseDataSets.default)([...responseChunks, normalizedResponseData]);
-  }
-
-  async _setCacheEntry(cacheType, hash, value, cachemapOptions, _options, _context) {
-    try {
-      await this._cache.set(`${cacheType}::${hash}`, (0, _cloneDeep2.default)(value), cachemapOptions);
-    } catch (error) {}
-  }
-
-  async _setEntityAndRequestFieldPathCacheEntries(requestData, responseData, options, context) {
-    const operationNode = (0, _helpers.getOperationDefinitions)(requestData.ast, context.operation)[0];
-    const fieldsAndTypeNames = (0, _helpers.getChildFields)(operationNode);
-
-    if (!fieldsAndTypeNames) {
-      return;
-    }
-
-    await Promise.all(fieldsAndTypeNames.map(({
-      fieldNode
-    }) => {
-      return this._parseEntityAndRequestFieldPathCacheEntryData(fieldNode, {
-        requestFieldPath: context.operation
-      }, responseData, options, context);
-    }));
-  }
-
-  async _setEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
-    cacheMetadata,
-    entityData,
-    requestFieldPathData
-  }, options, context) {
-    const {
-      requestFieldPath,
-      responseDataPath
-    } = keysAndPaths;
-    const fieldData = (0, _get2.default)(entityData, responseDataPath);
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    const cacheability = cacheMetadata.get(requestFieldPath);
-
-    if ((0, _isUndefined2.default)(fieldData) || !fieldTypeInfo || !cacheability) {
-      return;
-    }
-
-    const promises = [];
-    promises.push(this._setRequestFieldPathCacheEntry(field, keysAndPaths, {
-      cacheability,
-      data: requestFieldPathData,
-      fieldTypeInfo
-    }, options, context));
-
-    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
-
-    if (!isEntity && fieldTypeInfo.hasArguments) {
-      (0, _unset2.default)(entityData, responseDataPath);
-    }
-
-    if (isEntity) {
-      promises.push(this._setEntityCacheEntry(keysAndPaths, {
-        cacheability,
-        data: entityData,
-        fieldTypeInfo
-      }, options, context));
-    }
-
-    await Promise.all(promises);
-  }
-
-  async _setEntityCacheEntry({
-    responseDataPath
-  }, {
-    cacheability,
-    data,
-    fieldTypeInfo
-  }, options, context) {
-    let fieldData = (0, _get2.default)(data, responseDataPath);
-    const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
-    const entityDataKey = `${fieldTypeName}::${fieldData[this._typeIDKey]}`;
-    const result = await this._checkCacheEntry(_core.DATA_ENTITIES, entityDataKey, options, context);
-
-    if (result) {
-      fieldData = this._mergeObjects(result.entry, fieldData);
-    }
-
-    await this._setCacheEntry(_core.DATA_ENTITIES, entityDataKey, fieldData, {
-      cacheHeaders: {
-        cacheControl: cacheability.printCacheControl()
-      },
-      tag: options.tag
-    }, options, context);
-    (0, _set2.default)(data, responseDataPath, {
-      __cacheKey: `${_core.DATA_ENTITIES}::${entityDataKey}`
-    });
-  }
-
-  _setFieldCacheability(field, ancestorKeysAndPaths, {
-    cacheMetadata,
-    data
-  }, options, context) {
-    const {
-      requestFieldPath: ancestorRequestFieldPath
-    } = ancestorKeysAndPaths;
-    const keysAndPaths = (0, _helpers.buildFieldKeysAndPaths)(field, ancestorKeysAndPaths, context);
-    const {
-      requestFieldPath,
-      responseDataPath
-    } = keysAndPaths;
-    const fieldData = (0, _get2.default)(data, responseDataPath);
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-
-    if (!(0, _isObjectLike2.default)(fieldData) && !(fieldTypeInfo !== null && fieldTypeInfo !== void 0 && fieldTypeInfo.hasDirectives)) {
-      return;
-    }
-
-    this._setFieldTypeCacheDirective(cacheMetadata, {
-      ancestorRequestFieldPath,
-      requestFieldPath
-    }, context);
-
-    if ((0, _isObjectLike2.default)(fieldData)) {
-      (0, _helpers.iterateChildFields)(field, fieldData, context.fragmentDefinitions, (childField, _typeName, _fragmentKind, _fragmentName, childIndex) => {
-        this._setFieldCacheability(childField, {
-          index: childIndex,
-          requestFieldPath,
-          responseDataPath
-        }, {
-          cacheMetadata,
-          data
-        }, options, context);
-      });
-    }
-  }
-
-  _setFieldTypeCacheDirective(cacheMetadata, {
-    ancestorRequestFieldPath,
-    requestFieldPath
-  }, {
-    fieldTypeMap,
-    operation
-  }) {
-    if (cacheMetadata.has(requestFieldPath)) {
-      return;
-    }
-
-    const fieldTypeInfo = fieldTypeMap.get(requestFieldPath);
-
-    if (fieldTypeInfo && this._typeCacheDirectives[fieldTypeInfo.typeName]) {
-      const cacheability = new _cacheability2.default({
-        cacheControl: this._typeCacheDirectives[fieldTypeInfo.typeName]
-      });
-
-      CacheManager._setCacheMetadata(cacheMetadata, cacheability, requestFieldPath, operation);
-    } else if (this._cascadeCacheControl && ancestorRequestFieldPath) {
-      CacheManager._setCacheMetadata(cacheMetadata, cacheMetadata.get(ancestorRequestFieldPath), requestFieldPath, operation);
-    }
-  }
-
-  async _setPartialQueryResponse(hash, partialQueryResponse, _options, _context) {
-    this._partialQueryResponses.set(hash, partialQueryResponse);
-  }
-
-  async _setQueryResponseCacheEntry(hash, {
-    cacheMetadata,
-    data
-  }, options, context) {
-    const dehydratedCacheMetadata = (0, _helpers.dehydrateCacheMetadata)(cacheMetadata);
-
-    const cacheControl = CacheManager._getOperationCacheControl(cacheMetadata, context.operation);
-
-    await this._setCacheEntry(_core.QUERY_RESPONSES, hash, {
-      cacheMetadata: dehydratedCacheMetadata,
-      data
-    }, {
-      cacheHeaders: {
-        cacheControl
-      },
-      tag: options.tag
-    }, options, context);
-  }
-
-  async _setRequestFieldPathCacheEntry(field, keysAndPaths, {
-    cacheability,
-    data,
-    fieldTypeInfo
-  }, options, context) {
-    const {
-      hashedRequestFieldCacheKey,
-      requestFieldCacheKey,
-      responseDataPath
-    } = keysAndPaths;
-    let fieldData = (0, _get2.default)(data, responseDataPath);
-
-    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
-
-    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
-
-    if (context.operation === _core.QUERY && (isEntity || hasArgsOrDirectives)) {
-      var _field$selectionSet;
-
-      if ((0, _isPlainObject2.default)(fieldData) && (_field$selectionSet = field.selectionSet) !== null && _field$selectionSet !== void 0 && _field$selectionSet.selections) {
-        fieldData = (0, _filterOutPropsWithArgsOrDirectives.default)(fieldData, field.selectionSet.selections, keysAndPaths, context);
-      }
-
-      const result = await this._checkCacheEntry(_core.REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, { ...context,
-        requestFieldCacheKey
-      });
-
-      if (result && (0, _isObjectLike2.default)(fieldData)) {
-        fieldData = this._mergeObjects(result.entry, fieldData);
-      }
-
-      await this._setCacheEntry(_core.REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, fieldData, {
-        cacheHeaders: {
-          cacheControl: cacheability.printCacheControl()
-        },
-        tag: options.tag
-      }, options, { ...context,
-        requestFieldCacheKey
-      });
-
-      if ((0, _helpers.hasChildFields)(field, {
-        fragmentDefinitions: context.fragmentDefinitions
-      })) {
-        if (isEntity) {
-          (0, _set2.default)(data, responseDataPath, {
-            __cacheKey: `${_core.REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}`
-          });
-        } else {
-          (0, _unset2.default)(data, responseDataPath);
-        }
-      }
-    }
-  }
-
-  _setResponseChunksAwaitingCaching(normalizedResponseData, context) {
-    const responseChunks = this._responseChunksAwaitingCaching.get(context.requestID);
-
-    if (responseChunks) {
-      this._responseChunksAwaitingCaching.set(context.requestID, [...responseChunks, normalizedResponseData]);
-    } else {
-      this._responseChunksAwaitingCaching.set(context.requestID, [normalizedResponseData]);
-    }
-  }
-
-}, ((0, _applyDecoratedDescriptor2.default)(_class.prototype, "_getCacheEntry", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "_getCacheEntry"), _class.prototype), (0, _applyDecoratedDescriptor2.default)(_class.prototype, "_setCacheEntry", [_dec2], Object.getOwnPropertyDescriptor(_class.prototype, "_setCacheEntry"), _class.prototype), (0, _applyDecoratedDescriptor2.default)(_class.prototype, "_setPartialQueryResponse", [_dec3], Object.getOwnPropertyDescriptor(_class.prototype, "_setPartialQueryResponse"), _class.prototype)), _class));
-exports.default = CacheManager;
-//# sourceMappingURL=index.js.map