@graphql-box/cache-manager 4.1.4 → 5.0.0

package/dist/cjs/index.cjs

@@ -0,0 +1,1477 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _applyDecoratedDescriptor = require('@babel/runtime/helpers/applyDecoratedDescriptor');
+require('core-js/modules/es.array.push.js');
+var core = require('@graphql-box/core');
+var helpers = require('@graphql-box/helpers');
+var cacheability = require('cacheability');
+var graphql = require('graphql');
+var lodashEs = require('lodash-es');
+
+const METADATA = 'metadata';
+const CACHE_CONTROL = 'cacheControl';
+const NO_CACHE = 'noCache';
+const HEADER_CACHE_CONTROL = 'cache-control';
+const HEADER_NO_CACHE = 'no-cache';
+
+const logCacheEntry = () => {
+  return (_target, _propertyName, descriptor) => {
+    const method = descriptor.value;
+    if (!method) {
+      return;
+    }
+    descriptor.value = async function descriptorValue(...args) {
+      return new Promise(resolve => {
+        void (async () => {
+          const {
+            debugManager,
+            requestFieldCacheKey,
+            ...otherContext
+          } = args[5];
+          if (!debugManager) {
+            await method.apply(this, args);
+            resolve();
+            return;
+          }
+          const startTime = debugManager.now();
+          await method.apply(this, args);
+          const endTime = debugManager.now();
+          const duration = endTime - startTime;
+          resolve();
+          const payload = {
+            cacheType: args[0],
+            cachemapOptions: args[3],
+            context: otherContext,
+            options: args[4],
+            requestHash: args[1],
+            stats: {
+              duration,
+              endTime,
+              startTime
+            },
+            value: args[2],
+            ...(requestFieldCacheKey ? {
+              decryptedCacheKey: requestFieldCacheKey
+            } : {})
+          };
+          debugManager.log(core.CACHE_ENTRY_ADDED, payload);
+        })();
+      });
+    };
+  };
+};
+
+const logCacheQuery = () => {
+  return (_target, _propertyName, descriptor) => {
+    const method = descriptor.value;
+    if (!method) {
+      return;
+    }
+    descriptor.value = async function descriptorValue(...args) {
+      return new Promise(resolve => {
+        void (async () => {
+          const {
+            debugManager,
+            requestFieldCacheKey,
+            ...otherContext
+          } = args[3];
+          if (!debugManager) {
+            resolve(await method.apply(this, args));
+            return;
+          }
+          const startTime = debugManager.now();
+          const result = await method.apply(this, args);
+          const endTime = debugManager.now();
+          const duration = endTime - startTime;
+          resolve(result);
+          const payload = {
+            cacheType: args[0],
+            context: otherContext,
+            options: args[2],
+            requestHash: args[1],
+            result,
+            stats: {
+              duration,
+              endTime,
+              startTime
+            },
+            ...(requestFieldCacheKey ? {
+              decryptedCacheKey: requestFieldCacheKey
+            } : {})
+          };
+          debugManager.log(core.CACHE_ENTRY_QUERIED, payload);
+        })();
+      });
+    };
+  };
+};
+
+const logPartialCompiled = () => {
+  return (_target, _propertyName, descriptor) => {
+    const method = descriptor.value;
+    if (!method) {
+      return;
+    }
+    descriptor.value = function descriptorValue(...args) {
+      const {
+        debugManager,
+        ...otherContext
+      } = args[3];
+      if (!debugManager) {
+        method.apply(this, args);
+        return;
+      }
+      const startTime = debugManager.now();
+      method.apply(this, args);
+      const endTime = debugManager.now();
+      const duration = endTime - startTime;
+      debugManager.log(core.PARTIAL_QUERY_COMPILED, {
+        context: otherContext,
+        options: args[2],
+        requestHash: args[0],
+        result: args[1],
+        stats: {
+          duration,
+          endTime,
+          startTime
+        }
+      });
+    };
+  };
+};
+
+const checkValue = (value, typeIDKey) => {
+  if (helpers.isArray(value)) {
+    return value.reduce((acc, entry) => {
+      if (!acc) {
+        return false;
+      }
+      return checkValue(entry, typeIDKey);
+    }, true);
+  }
+  if (helpers.isPlainObject(value)) {
+    return recursivelyCheckProps(value, typeIDKey);
+  }
+  return false;
+};
+const recursivelyCheckProps = (data, typeIDKey) => {
+  const keys = helpers.isPlainObject(data) ? Object.keys(data) : [...data.keys()];
+  if (keys.length === 1 && helpers.isPlainObject(data) && !!data[typeIDKey]) {
+    return true;
+  }
+  return keys.reduce((acc, key) => {
+    if (!acc) {
+      return false;
+    }
+    if (lodashEs.isNumber(key) && helpers.isArray(data)) {
+      return checkValue(data[key], typeIDKey);
+    } else if (lodashEs.isString(key) && helpers.isPlainObject(data)) {
+      return checkValue(data[key], typeIDKey);
+    }
+    return acc;
+  }, true);
+};
+const areOnlyPopulatedFieldsTypeIdKeys = (data, typeIDKey) => {
+  return recursivelyCheckProps(data, typeIDKey);
+};
+
+const mergeDataSets = (obj, source, typeIDKey) => {
+  return helpers.mergeObjects(obj, source, (_key, value) => {
+    return helpers.isPlainObject(value) && value[typeIDKey] ? value[typeIDKey] : undefined;
+  });
+};
+
+const combineDataSets = (dataSetA, dataSetB, typeIDKey) => {
+  if (!dataSetA && dataSetB) {
+    return dataSetB;
+  }
+  if (helpers.isObjectLike(dataSetA) && helpers.isObjectLike(dataSetB)) {
+    return mergeDataSets(dataSetA, dataSetB, typeIDKey);
+  }
+  return dataSetA;
+};
+
+const deriveOpCacheability = ({
+  _cacheMetadata,
+  fallback,
+  headers
+}) => {
+  if (_cacheMetadata && !lodashEs.isEmpty(_cacheMetadata)) {
+    const [first, ...rest] = Object.values(_cacheMetadata);
+    return new cacheability.Cacheability({
+      metadata: rest.reduce((acc, metadata) => {
+        if (!acc) {
+          return metadata;
+        }
+        if (metadata.ttl < acc.ttl) {
+          return metadata;
+        }
+        return acc;
+      }, first)
+    });
+  }
+  if (headers?.has(HEADER_CACHE_CONTROL)) {
+    return new cacheability.Cacheability({
+      headers
+    });
+  }
+  return new cacheability.Cacheability({
+    cacheControl: fallback
+  });
+};
+
+const filterOutPropsWithArgsOrDirectives = (fieldData, selectionNodes, ancestorKeysAndPaths, context) => {
+  const fieldAndTypeName = helpers.resolveFragments(selectionNodes, context.fragmentDefinitions);
+  return lodashEs.keys(fieldData).reduce((acc, key) => {
+    const match = fieldAndTypeName.find(({
+      fieldNode
+    }) => helpers.getName(fieldNode) === key);
+    if (match) {
+      const {
+        requestFieldPath
+      } = helpers.buildFieldKeysAndPaths(match.fieldNode, ancestorKeysAndPaths, context);
+      const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+      if (!fieldTypeInfo?.hasArguments && !fieldTypeInfo?.hasDirectives) {
+        acc[key] = fieldData[key];
+      }
+    }
+    return acc;
+  }, {});
+};
+
+const createFragmentSpreadChecklist = ({
+  request
+}, {
+  fragmentDefinitions
+}) => lodashEs.keys(fragmentDefinitions ?? {}).reduce((acc, name) => {
+  acc[name] = {
+    deleted: 0,
+    paths: [],
+    total: (request.match(new RegExp(`\\.\\.\\.${name}`, 'g')) ?? []).length
+  };
+  return acc;
+}, {});
+
+const checkFieldPathChecklist = (fieldPathChecklistValues, fieldTypeName) => {
+  if (!fieldPathChecklistValues || fieldPathChecklistValues.length === 0) {
+    return {
+      hasData: false,
+      typeUnused: !!fieldTypeName
+    };
+  }
+  const [fieldPathChecklistValue] = fieldPathChecklistValues;
+  if (fieldPathChecklistValue) {
+    const {
+      hasData,
+      typeName
+    } = fieldPathChecklistValue;
+    const typeUnused = typeName ? typeName !== fieldTypeName : undefined;
+    return {
+      hasData,
+      typeUnused
+    };
+  }
+  return {
+    hasData: fieldPathChecklistValues.some(({
+      hasData,
+      typeName
+    }) => typeName === fieldTypeName && hasData),
+    typeUnused: !fieldPathChecklistValues.every(({
+      typeName
+    }) => typeName === fieldTypeName)
+  };
+};
+
+const filterFragmentSpreads = (field, fragmentSpreadFieldCounter, fragmentSpreadChecklist, ancestorRequestFieldPath) => {
+  if (lodashEs.isEmpty(fragmentSpreadFieldCounter)) {
+    return;
+  }
+  for (const key of Object.keys(fragmentSpreadFieldCounter)) {
+    const checklist = fragmentSpreadChecklist[key];
+    if (!checklist) {
+      continue;
+    }
+    checklist.paths.push(ancestorRequestFieldPath);
+    const {
+      hasData,
+      total
+    } = fragmentSpreadFieldCounter[key];
+    if (hasData === total) {
+      helpers.deleteFragmentSpreads(field, key);
+      checklist.deleted += 1;
+    }
+  }
+};
+
+const filterIDsAndTypeNames = (field, {
+  fragmentDefinitions,
+  typeIDKey
+}) => {
+  const fieldsAndTypeNames = helpers.getChildFields(field, {
+    fragmentDefinitions
+  });
+  if (!fieldsAndTypeNames || fieldsAndTypeNames.length > 3) {
+    return false;
+  }
+  const fieldNames = fieldsAndTypeNames.map(({
+    fieldNode
+  }) => helpers.getName(fieldNode));
+  if (fieldNames.length === 2 && fieldNames.every(name => name === typeIDKey || name === core.TYPE_NAME_KEY)) {
+    helpers.deleteChildFields(field, fieldsAndTypeNames.map(({
+      fieldNode
+    }) => fieldNode));
+    return true;
+  }
+  if (fieldNames.length === 1 && fieldNames[0] === typeIDKey || fieldNames[0] === core.TYPE_NAME_KEY) {
+    const [fieldAndTypeName] = fieldsAndTypeNames;
+    if (fieldAndTypeName) {
+      const {
+        fieldNode
+      } = fieldAndTypeName;
+      helpers.deleteChildFields(field, fieldNode);
+      return true;
+    }
+  }
+  return false;
+};
+
+const filterInlineFragments = (field, {
+  fragmentDefinitions,
+  typeIDKey
+}) => {
+  const inlineFragments = helpers.getInlineFragments(field);
+  let filtered = false;
+  for (const fragment of inlineFragments) {
+    const fieldsAndTypeNames = helpers.getChildFields(fragment, {
+      fragmentDefinitions
+    });
+    if (!fieldsAndTypeNames || fieldsAndTypeNames.length === 0) {
+      helpers.deleteInlineFragments(field, fragment);
+      filtered = true;
+      continue;
+    }
+    const [fieldAndTypeName] = fieldsAndTypeNames;
+    if (fieldAndTypeName) {
+      const {
+        fieldNode
+      } = fieldAndTypeName;
+      if (helpers.getName(fieldNode) === typeIDKey) {
+        helpers.deleteInlineFragments(field, fragment);
+        filtered = true;
+      }
+    }
+  }
+  return filtered;
+};
+
+const filterField = (field, fieldPathChecklist, fragmentSpreadChecklist, ancestorRequestFieldPath, context) => {
+  const {
+    fragmentDefinitions,
+    typeIDKey
+  } = context;
+  const fieldsAndTypeNames = helpers.getChildFields(field, {
+    fragmentDefinitions
+  });
+  if (!fieldsAndTypeNames) {
+    return false;
+  }
+  const fragmentSpreadFieldCounter = {};
+  for (let index = fieldsAndTypeNames.length - 1; index >= 0; index -= 1) {
+    const fieldAndTypeName = fieldsAndTypeNames[index];
+    if (!fieldAndTypeName) {
+      continue;
+    }
+    const {
+      fieldNode: childField,
+      fragmentKind,
+      fragmentName,
+      typeName: childTypeName
+    } = fieldAndTypeName;
+    if (fragmentKind === graphql.Kind.FRAGMENT_SPREAD && fragmentName && !fragmentSpreadFieldCounter[fragmentName]) {
+      fragmentSpreadFieldCounter[fragmentName] = {
+        hasData: 0,
+        total: fragmentDefinitions?.[fragmentName] ? helpers.getChildFields(fragmentDefinitions[fragmentName], {
+          fragmentDefinitions
+        })?.length ?? 0 : 0
+      };
+    }
+    const childFieldName = helpers.getName(childField);
+    if (childFieldName === typeIDKey || childFieldName === core.TYPE_NAME_KEY) {
+      continue;
+    }
+    const {
+      requestFieldPath
+    } = helpers.buildFieldKeysAndPaths(childField, {
+      requestFieldPath: ancestorRequestFieldPath
+    }, context);
+    const {
+      hasData,
+      typeUnused
+    } = checkFieldPathChecklist(fieldPathChecklist.get(requestFieldPath), childTypeName);
+    if (hasData || typeUnused) {
+      if (fragmentKind === graphql.Kind.FRAGMENT_SPREAD && fragmentName) {
+        const counter = fragmentSpreadFieldCounter[fragmentName];
+        if (counter) {
+          counter.hasData += 1;
+        }
+      } else if (!helpers.hasChildFields(childField, {
+        fragmentDefinitions
+      })) {
+        helpers.deleteChildFields(field, childField);
+      } else if (filterField(childField, fieldPathChecklist, fragmentSpreadChecklist, requestFieldPath, context)) {
+        helpers.deleteChildFields(field, childField);
+      }
+    }
+  }
+  filterFragmentSpreads(field, fragmentSpreadFieldCounter, fragmentSpreadChecklist, ancestorRequestFieldPath);
+  filterInlineFragments(field, context);
+  filterIDsAndTypeNames(field, context);
+  return !helpers.hasChildFields(field, {
+    fragmentDefinitions
+  });
+};
+
+const filterFragmentDefinitions = (ast, fieldPathChecklist, fragmentSpreadChecklist, context) => {
+  const definitionsToFilter = lodashEs.keys(fragmentSpreadChecklist).reduce((namesAndPaths, key) => {
+    const checklist = fragmentSpreadChecklist[key];
+    if (!checklist) {
+      return namesAndPaths;
+    }
+    const {
+      deleted,
+      paths,
+      total
+    } = checklist;
+    return deleted === 0 && total === 1 ? [...namesAndPaths, {
+      name: key,
+      path: paths[0]
+    }] : namesAndPaths;
+  }, []);
+  const {
+    fragmentDefinitions = {}
+  } = context;
+  for (const {
+    name,
+    path
+  } of definitionsToFilter) {
+    const fragmentDefinition = fragmentDefinitions[name];
+    if (!fragmentDefinition) {
+      continue;
+    }
+    filterField(fragmentDefinition, fieldPathChecklist, fragmentSpreadChecklist, path, context);
+  }
+  const definitionsToDelete = lodashEs.keys(fragmentSpreadChecklist).reduce((names, key) => {
+    const checklist = fragmentSpreadChecklist[key];
+    if (!checklist) {
+      return names;
+    }
+    const {
+      deleted,
+      total
+    } = checklist;
+    return deleted > 0 && deleted === total ? [...names, key] : names;
+  }, []);
+  if (definitionsToDelete.length === 0) {
+    return ast;
+  }
+  return helpers.deleteFragmentDefinitions(ast, {
+    include: definitionsToDelete
+  });
+};
+
+const filterQuery = (requestData, {
+  fieldPathChecklist
+}, context) => {
+  const {
+    ast
+  } = requestData;
+  const queryNode = helpers.getOperationDefinitions(ast, context.operation)[0];
+  if (!queryNode) {
+    return ast;
+  }
+  const {
+    fragmentDefinitions,
+    operation
+  } = context;
+  const fieldsAndTypeNames = helpers.getChildFields(queryNode, {
+    fragmentDefinitions
+  });
+  if (!fieldsAndTypeNames) {
+    return ast;
+  }
+  const fragmentSpreadChecklist = createFragmentSpreadChecklist(requestData, context);
+  for (let index = fieldsAndTypeNames.length - 1; index >= 0; index -= 1) {
+    const {
+      fieldNode
+    } = fieldsAndTypeNames[index];
+    const {
+      requestFieldPath
+    } = helpers.buildFieldKeysAndPaths(fieldNode, {
+      requestFieldPath: operation
+    }, context);
+    if (filterField(fieldNode, fieldPathChecklist, fragmentSpreadChecklist, requestFieldPath, context)) {
+      helpers.deleteChildFields(queryNode, fieldNode);
+    }
+  }
+  context.queryFiltered = true;
+  return filterFragmentDefinitions(ast, fieldPathChecklist, fragmentSpreadChecklist, context);
+};
+
+const getDataValue = (value, key) => {
+  if (helpers.isArray(value) && lodashEs.isNumber(key)) {
+    return value[key];
+  }
+  if (helpers.isPlainObject(value) && lodashEs.isString(key)) {
+    return value[key];
+  }
+  return;
+};
+
+const hasTypename = value => {
+  if (!helpers.isObjectLike(value)) {
+    return false;
+  }
+  return core.TYPE_NAME_KEY in value && lodashEs.isString(value[core.TYPE_NAME_KEY]);
+};
+
+const isLastResponseChunk = (rawResponseData, context) => context.hasDeferOrStream && !rawResponseData.hasNext && rawResponseData.paths;
+
+const isNotLastResponseChunk = (rawResponseData, context) => context.hasDeferOrStream && rawResponseData.hasNext;
+
+const isNotResponseChunk = (rawResponseData, context) => !context.hasDeferOrStream && !rawResponseData.hasNext && !rawResponseData.paths;
+
+const mergeResponseDataSets = responseDataSets => {
+  return responseDataSets.reduce((acc, dataSet, index) => {
+    const {
+      _cacheMetadata,
+      data,
+      hasNext,
+      headers,
+      paths
+    } = dataSet;
+    if (_cacheMetadata) {
+      acc._cacheMetadata = acc._cacheMetadata ? {
+        ...acc._cacheMetadata,
+        ..._cacheMetadata
+      } : _cacheMetadata;
+    }
+    acc.data = lodashEs.merge(acc.data, data);
+    if (index === 0) {
+      acc.headers = headers;
+    }
+    if (index === responseDataSets.length - 1) {
+      acc.hasNext = hasNext;
+    }
+    if (paths) {
+      if (!acc.paths) {
+        acc.paths = [];
+      }
+      acc.paths.push(...paths);
+    }
+    return acc;
+  }, {
+    data: {}
+  });
+};
+
+const normalizePatchResponseData = (rawResponseData, context) => {
+  if (!context.normalizePatchResponseData) {
+    return rawResponseData;
+  }
+  const {
+    data,
+    paths,
+    ...rest
+  } = rawResponseData;
+  if (!paths?.length || !lodashEs.isString(paths[0])) {
+    return rawResponseData;
+  }
+  return {
+    ...rest,
+    data: lodashEs.set({}, paths[0], data),
+    paths
+  };
+};
+
+const getValidTypeIdValue = (requestFieldPathData, {
+  typeIDValue
+}, typeIDKey) => {
+  if (typeIDValue) {
+    return typeIDValue;
+  }
+  if (helpers.isPlainObject(requestFieldPathData)) {
+    return requestFieldPathData[typeIDKey];
+  }
+  return;
+};
+
+var _dec, _dec2, _dec3, _class;
+let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = logPartialCompiled(), (_class = class CacheManager {
+  static _countFieldPathChecklist(fieldPathChecklist) {
+    const fieldCount = {
+      missing: 0,
+      total: 0
+    };
+    for (const [, checklistValues] of fieldPathChecklist) {
+      fieldCount.total += checklistValues.length;
+      const missing = checklistValues.filter(({
+        hasData
+      }) => !hasData);
+      fieldCount.missing += missing.length;
+    }
+    return fieldCount;
+  }
+  static _getFieldDataFromAncestor(ancestorFieldData, propNameOrIndex) {
+    const dataValue = getDataValue(ancestorFieldData, propNameOrIndex);
+    return helpers.isObjectLike(dataValue) ? lodashEs.cloneDeep(dataValue) : dataValue;
+  }
+  static _getOperationCacheControl(cacheMetadata, operation) {
+    const defaultCacheControl = 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 = lodashEs.get(cacheability, [METADATA, CACHE_CONTROL, NO_CACHE], false);
+    return !noCache && cacheability.checkTTL();
+  }
+  static _mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse) {
+    if (!partialQueryResponse) {
+      return cacheMetadata;
+    }
+    return new Map([...partialQueryResponse.cacheMetadata, ...cacheMetadata]);
+  }
+  static _setCachedData(responseData, {
+    data
+  }, propNameOrIndex) {
+    const setData = value => {
+      if (helpers.isArray(responseData) && lodashEs.isNumber(propNameOrIndex)) {
+        responseData[propNameOrIndex] = value;
+      } else if (helpers.isPlainObject(responseData)) {
+        responseData[propNameOrIndex] = value;
+      }
+    };
+    if (!helpers.isObjectLike(data) && !lodashEs.isUndefined(data)) {
+      setData(data);
+    } else if (helpers.isArray(data)) {
+      setData([]);
+    } else if (helpers.isPlainObject(data)) {
+      setData({});
+    }
+  }
+  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: dataTypeName,
+    fieldTypename: fieldTypeName,
+    fragmentKind,
+    fragmentName
+  }) {
+    if (lodashEs.isUndefined(fieldTypeName) || fragmentKind === graphql.Kind.FRAGMENT_SPREAD) {
+      if (fieldPathChecklist.has(requestFieldPath)) {
+        return;
+      }
+      fieldPathChecklist.set(requestFieldPath, [{
+        fragmentKind,
+        fragmentName,
+        hasData: !lodashEs.isUndefined(data)
+      }]);
+      return;
+    }
+    if (dataTypeName !== fieldTypeName) {
+      return;
+    }
+    const entry = fieldPathChecklist.get(requestFieldPath);
+    const checklistValues = entry ?? [];
+    if (checklistValues.some(({
+      typeName
+    }) => typeName === dataTypeName)) {
+      return;
+    }
+    fieldPathChecklist.set(requestFieldPath, [...checklistValues, {
+      fragmentKind,
+      fragmentName,
+      hasData: !lodashEs.isUndefined(data),
+      typeName: dataTypeName
+    }]);
+  }
+  constructor(options) {
+    _defineProperty(this, "_cache", void 0);
+    _defineProperty(this, "_cascadeCacheControl", void 0);
+    _defineProperty(this, "_fallbackOperationCacheability", void 0);
+    _defineProperty(this, "_partialQueryResponses", new Map());
+    _defineProperty(this, "_responseChunksAwaitingCaching", new Map());
+    _defineProperty(this, "_typeCacheDirectives", void 0);
+    _defineProperty(this, "_typeIDKey", void 0);
+    const errors = [];
+    if (!('cache' in options)) {
+      errors.push(new helpers.ArgsError('@graphql-box/cache-manager expected cache to be in options.'));
+    }
+    if (!!options.typeCacheDirectives && !helpers.isPlainObject(options.typeCacheDirectives)) {
+      const message = '@graphql-box/cache-manager expected options.typeCacheDirectives to be a plain object.';
+      errors.push(new helpers.ArgsError(message));
+    }
+    if (errors.length > 0) {
+      throw new helpers.GroupedError('@graphql-box/cache-manager argument validation errors.', errors);
+    }
+    this._cache = options.cache;
+    this._cascadeCacheControl = options.cascadeCacheControl ?? false;
+    this._fallbackOperationCacheability = options.fallbackOperationCacheability ?? NO_CACHE;
+    this._typeCacheDirectives = options.typeCacheDirectives ?? {};
+    this._typeIDKey = options.typeIDKey ?? core.DEFAULT_TYPE_ID_KEY;
+  }
+  async analyzeQuery(requestData, options, context) {
+    const {
+      ast,
+      hash
+    } = requestData;
+    const cacheManagerContext = {
+      ...context,
+      fragmentDefinitions: helpers.getFragmentDefinitions(ast),
+      typeIDKey: this._typeIDKey
+    };
+    const cachedResponseData = await this._retrieveCachedResponseData(requestData, options, cacheManagerContext);
+    const {
+      cacheMetadata,
+      data,
+      fieldCount
+    } = cachedResponseData;
+    if (fieldCount.missing === fieldCount.total || areOnlyPopulatedFieldsTypeIdKeys(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 = filterQuery(requestData, cachedResponseData, cacheManagerContext);
+    const filteredRequest = graphql.print(filteredAST);
+    const {
+      fragmentDefinitions,
+      typeIDKey,
+      ...rest
+    } = cacheManagerContext;
+    lodashEs.assign(context, {
+      ...rest,
+      filteredRequest
+    });
+    this._setPartialQueryResponse(hash, {
+      cacheMetadata,
+      data
+    }, options, context);
+    return {
+      updated: {
+        ast: filteredAST,
+        hash: helpers.hashRequest(filteredRequest),
+        request: filteredRequest
+      }
+    };
+  }
+  get cache() {
+    return this._cache;
+  }
+  async cacheQuery(requestData, updatedRequestData, rawResponseData, options, context) {
+    const cacheManagerContext = {
+      ...context,
+      fragmentDefinitions: helpers.getFragmentDefinitions((updatedRequestData ?? requestData).ast),
+      typeIDKey: this._typeIDKey
+    };
+    return this._cacheResponse(requestData, updatedRequestData, rawResponseData, options, cacheManagerContext);
+  }
+  async cacheResponse(requestData, rawResponseData, options, context) {
+    const cacheManagerContext = {
+      ...context,
+      fragmentDefinitions: 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: 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) {
+    await (helpers.hasChildFields(fieldNode, {
+      fragmentDefinitions: context.fragmentDefinitions
+    }) ? this._analyzeParentFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) : this._analyzeLeafFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context));
+  }
+  async _analyzeLeafFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
+    const keysAndPaths = 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 dataTypename = hasTypename(entityData) ? entityData.__typename : hasTypename(requestFieldPathData) ? requestFieldPathData.__typename : undefined;
+    const typenamesAndKind = {
+      dataTypename,
+      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 = 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: lodashEs.get(data, core.TYPE_NAME_KEY),
+      fieldTypename: typeName,
+      fragmentKind,
+      fragmentName
+    }, options, context);
+    if (!helpers.isObjectLike(data)) {
+      return;
+    }
+    const promises = [];
+    helpers.iterateChildFields(fieldNode, data, 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: getDataValue(cachedResponseData.data, propNameOrIndex)
+      }, options, context));
+    });
+    await Promise.all(promises);
+  }
+  _buildCacheMetadata({
+    ast
+  }, {
+    data,
+    ...otherProps
+  }, options, context) {
+    const cacheMetadata = this._createCacheMetadata({
+      data,
+      ...otherProps
+    }, context);
+    const queryNode = helpers.getOperationDefinitions(ast, context.operation)[0];
+    if (!queryNode) {
+      return cacheMetadata;
+    }
+    const fieldsAndTypeNames = helpers.getChildFields(queryNode);
+    if (!fieldsAndTypeNames) {
+      return cacheMetadata;
+    }
+    for (const {
+      fieldNode
+    } of fieldsAndTypeNames) this._setFieldCacheability(fieldNode, {
+      requestFieldPath: context.operation
+    }, {
+      cacheMetadata,
+      data
+    }, options, context);
+    return cacheMetadata;
+  }
+  async _cacheResponse(requestData, updatedRequestData, rawResponseData, options, context) {
+    const normalizedResponseData = normalizePatchResponseData(rawResponseData, context);
+    let responseDataForCaching = normalizedResponseData;
+    if (isNotLastResponseChunk(rawResponseData, context)) {
+      this._setResponseChunksAwaitingCaching(normalizedResponseData, context);
+      responseDataForCaching = undefined;
+    }
+    if (isLastResponseChunk(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: lodashEs.cloneDeep(data),
+        requestFieldPathData: lodashEs.cloneDeep(data)
+      }, options, context));
+      let queryCacheMetadata;
+      let queryData;
+      if (context.operation === graphql.OperationTypeNode.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 (isNotResponseChunk(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 (lodashEs.isUndefined(entry)) {
+        return false;
+      }
+      return {
+        cacheability,
+        entry
+      };
+    } catch {
+      return false;
+    }
+  }
+  _createCacheMetadata({
+    _cacheMetadata,
+    headers
+  }, {
+    operation
+  }) {
+    const cacheMetadata = new Map();
+    const cacheability = deriveOpCacheability({
+      _cacheMetadata,
+      fallback: this._fallbackOperationCacheability,
+      headers
+    });
+    cacheMetadata.set(operation, cacheability);
+    if (_cacheMetadata) {
+      helpers.rehydrateCacheMetadata(_cacheMetadata, cacheMetadata);
+    }
+    return cacheMetadata;
+  }
+  async _getCacheEntry(cacheType, hash, _options, _context) {
+    return this._cache.get(`${cacheType}::${hash}`);
+  }
+  _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 {
+      return false;
+    }
+  }
+  _isFieldEntity(fieldData, {
+    isEntity,
+    possibleTypes
+  }) {
+    if (!helpers.isPlainObject(fieldData) || !(this._typeIDKey in fieldData)) {
+      return false;
+    }
+    if (isEntity) {
+      return true;
+    }
+    if (possibleTypes.length === 0) {
+      return false;
+    }
+    return possibleTypes.some(type => type.typeName === fieldData.__typename);
+  }
+  _mergeResponseData(responseData, partialQueryResponse) {
+    if (!partialQueryResponse) {
+      return responseData;
+    }
+    return mergeDataSets(partialQueryResponse.data, responseData, this._typeIDKey);
+  }
+  async _parseEntityAndRequestFieldPathCacheEntryData(field, ancestorKeysAndPaths, {
+    cacheMetadata,
+    entityData,
+    requestFieldPathData
+  }, options, context) {
+    const keysAndPaths = helpers.buildFieldKeysAndPaths(field, ancestorKeysAndPaths, context);
+    const {
+      requestFieldCacheKey,
+      requestFieldPath,
+      responseDataPath
+    } = keysAndPaths;
+    const fieldData = lodashEs.get(requestFieldPathData, responseDataPath);
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+    if (!helpers.isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
+      return;
+    }
+    if (helpers.isObjectLike(fieldData)) {
+      const promises = [];
+      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
+        }) => mergeDataSets(obj, entry, this._typeIDKey), {})
+      };
+    }
+    return validResult ?? {};
+  }
+  async _retrieveCachedParentNodeData({
+    entityData: ancestorEntityData,
+    requestFieldPathData: ancestorRequestFieldPathData
+  }, {
+    hashedRequestFieldCacheKey,
+    propNameOrIndex,
+    requestFieldCacheKey
+  }, fieldTypeInfo, options, context) {
+    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);
+      requestFieldPathData = combineDataSets(requestFieldPathData, entry, this._typeIDKey);
+      if (entryCacheability) {
+        cacheability = entryCacheability;
+      }
+    }
+    const validTypeIDValue = getValidTypeIdValue(requestFieldPathData, fieldTypeInfo, this._typeIDKey);
+    if (CacheManager._isNodeEntity(fieldTypeInfo) && validTypeIDValue) {
+      const {
+        cacheability: entryCacheability,
+        entry
+      } = await this._retrieveCachedEntityData(validTypeIDValue, fieldTypeInfo, options, context);
+      entityData = combineDataSets(entityData, entry, this._typeIDKey);
+      if (entryCacheability && (!cacheability || entryCacheability.metadata.ttl > cacheability.metadata.ttl)) {
+        cacheability = entryCacheability;
+      }
+    }
+    const data = lodashEs.isEqual(entityData, requestFieldPathData) ? entityData : combineDataSets(entityData, requestFieldPathData, this._typeIDKey);
+    return {
+      cacheability,
+      data,
+      entityData,
+      requestFieldPathData
+    };
+  }
+  async _retrieveCachedRequestFieldPathData(hash, requestFieldCacheKey, options, context) {
+    return (await 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 = helpers.getOperationDefinitions(ast, context.operation)[0];
+    if (!queryNode) {
+      return cachedResponseData;
+    }
+    const fieldsAndTypeNames = 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 mergeResponseDataSets([...responseChunks, normalizedResponseData]);
+  }
+  async _setCacheEntry(cacheType, hash, value, cachemapOptions, _options, _context) {
+    try {
+      await this._cache.set(`${cacheType}::${hash}`, lodashEs.cloneDeep(value), cachemapOptions);
+    } catch {}
+  }
+  async _setEntityAndRequestFieldPathCacheEntries(requestData, responseData, options, context) {
+    const operationNode = helpers.getOperationDefinitions(requestData.ast, context.operation)[0];
+    if (!operationNode) {
+      return;
+    }
+    const fieldsAndTypeNames = 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 = lodashEs.get(entityData, responseDataPath);
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+    const cacheability = cacheMetadata.get(requestFieldPath);
+    if (lodashEs.isUndefined(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) {
+      lodashEs.unset(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 = lodashEs.get(data, responseDataPath);
+    const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
+    const entityDataKey = `${fieldTypeName}::${String(fieldData[this._typeIDKey])}`;
+    const result = await this._checkCacheEntry(core.DATA_ENTITIES, entityDataKey, options, context);
+    if (result) {
+      fieldData = mergeDataSets(result.entry, fieldData, this._typeIDKey);
+    }
+    await this._setCacheEntry(core.DATA_ENTITIES, entityDataKey, fieldData, {
+      cacheHeaders: {
+        cacheControl: cacheability.printCacheControl()
+      },
+      tag: options.tag
+    }, options, context);
+    lodashEs.set(data, responseDataPath, {
+      __cacheKey: `${core.DATA_ENTITIES}::${entityDataKey}`
+    });
+  }
+  _setFieldCacheability(field, ancestorKeysAndPaths, {
+    cacheMetadata,
+    data
+  }, options, context) {
+    const {
+      requestFieldPath: ancestorRequestFieldPath
+    } = ancestorKeysAndPaths;
+    const keysAndPaths = helpers.buildFieldKeysAndPaths(field, ancestorKeysAndPaths, context);
+    const {
+      requestFieldPath,
+      responseDataPath
+    } = keysAndPaths;
+    if (!helpers.isObjectLike(data)) {
+      return;
+    }
+    const fieldData = lodashEs.get(data, responseDataPath);
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+    if (!helpers.isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
+      return;
+    }
+    this._setFieldTypeCacheDirective(cacheMetadata, {
+      ancestorRequestFieldPath,
+      requestFieldPath
+    }, context);
+    if (helpers.isObjectLike(fieldData)) {
+      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$1 = new cacheability.Cacheability({
+        cacheControl: this._typeCacheDirectives[fieldTypeInfo.typeName]
+      });
+      CacheManager._setCacheMetadata(cacheMetadata, cacheability$1, requestFieldPath, operation);
+    } else if (this._cascadeCacheControl && ancestorRequestFieldPath) {
+      CacheManager._setCacheMetadata(cacheMetadata, cacheMetadata.get(ancestorRequestFieldPath), requestFieldPath, operation);
+    }
+  }
+  _setPartialQueryResponse(hash, partialQueryResponse, _options, _context) {
+    this._partialQueryResponses.set(hash, partialQueryResponse);
+  }
+  async _setQueryResponseCacheEntry(hash, {
+    cacheMetadata,
+    data
+  }, options, context) {
+    const dehydratedCacheMetadata = 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 = lodashEs.get(data, responseDataPath);
+    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
+    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
+    if (context.operation === graphql.OperationTypeNode.QUERY && (isEntity || hasArgsOrDirectives)) {
+      if (helpers.isPlainObject(fieldData) && field.selectionSet?.selections) {
+        fieldData = filterOutPropsWithArgsOrDirectives(fieldData, field.selectionSet.selections, keysAndPaths, context);
+      }
+      const result = await this._checkCacheEntry(core.REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, {
+        ...context,
+        requestFieldCacheKey
+      });
+      if (result && helpers.isObjectLike(result.entry) && helpers.isObjectLike(fieldData)) {
+        fieldData = mergeDataSets(result.entry, fieldData, this._typeIDKey);
+      }
+      await this._setCacheEntry(core.REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, fieldData, {
+        cacheHeaders: {
+          cacheControl: cacheability.printCacheControl()
+        },
+        tag: options.tag
+      }, options, {
+        ...context,
+        requestFieldCacheKey
+      });
+      if (helpers.hasChildFields(field, {
+        fragmentDefinitions: context.fragmentDefinitions
+      })) {
+        if (isEntity) {
+          lodashEs.set(data, responseDataPath, {
+            __cacheKey: `${core.REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}`
+          });
+        } else {
+          lodashEs.unset(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]);
+    }
+  }
+}, (_applyDecoratedDescriptor(_class.prototype, "_getCacheEntry", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "_getCacheEntry"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "_setCacheEntry", [_dec2], Object.getOwnPropertyDescriptor(_class.prototype, "_setCacheEntry"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "_setPartialQueryResponse", [_dec3], Object.getOwnPropertyDescriptor(_class.prototype, "_setPartialQueryResponse"), _class.prototype)), _class));
+
+exports.CacheManager = CacheManager;
+//# sourceMappingURL=index.cjs.map