@graphql-box/cache-manager 5.0.0 → 5.0.2

package/dist/cjs/index.cjs

@@ -1,1477 +1,2 @@
-'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;
+"use strict";var e=require("@babel/runtime/helpers/defineProperty"),t=require("@babel/runtime/helpers/applyDecoratedDescriptor");require("core-js/modules/es.array.push.js");var a=require("@graphql-box/core"),i=require("@graphql-box/helpers"),s=require("cacheability"),n=require("graphql"),r=require("lodash-es");const c="noCache",h=(e,t)=>i.isArray(e)?e.reduce(((e,a)=>!!e&&h(a,t)),!0):!!i.isPlainObject(e)&&o(e,t),o=(e,t)=>{const a=i.isPlainObject(e)?Object.keys(e):[...e.keys()];return!(1!==a.length||!i.isPlainObject(e)||!e[t])||a.reduce(((a,s)=>!!a&&(r.isNumber(s)&&i.isArray(e)||r.isString(s)&&i.isPlainObject(e)?h(e[s],t):a)),!0)},d=(e,t,a)=>i.mergeObjects(e,t,((e,t)=>i.isPlainObject(t)&&t[a]?t[a]:void 0)),l=(e,t,a)=>!e&&t?t:i.isObjectLike(e)&&i.isObjectLike(t)?d(e,t,a):e,y=({_cacheMetadata:e,fallback:t,headers:a})=>{if(e&&!r.isEmpty(e)){const[t,...a]=Object.values(e);return new s.Cacheability({metadata:a.reduce(((e,t)=>e?t.ttl<e.ttl?t:e:t),t)})}return a?.has("cache-control")?new s.Cacheability({headers:a}):new s.Cacheability({cacheControl:t})},p=(e,t)=>{if(!e||0===e.length)return{hasData:!1,typeUnused:!!t};const[a]=e;if(a){const{hasData:e,typeName:i}=a;return{hasData:e,typeUnused:i?i!==t:void 0}}return{hasData:e.some((({hasData:e,typeName:a})=>a===t&&e)),typeUnused:!e.every((({typeName:e})=>e===t))}},u=(e,t,s,c,h)=>{const{fragmentDefinitions:o,typeIDKey:d}=h,l=i.getChildFields(e,{fragmentDefinitions:o});if(!l)return!1;const y={};for(let r=l.length-1;r>=0;r-=1){const _=l[r];if(!_)continue;const{fieldNode:f,fragmentKind:g,fragmentName:C,typeName:D}=_;g===n.Kind.FRAGMENT_SPREAD&&C&&!y[C]&&(y[C]={hasData:0,total:o?.[C]?i.getChildFields(o[C],{fragmentDefinitions:o})?.length??0:0});const m=i.getName(f);if(m===d||m===a.TYPE_NAME_KEY)continue;const{requestFieldPath:F}=i.buildFieldKeysAndPaths(f,{requestFieldPath:c},h),{hasData:E,typeUnused:P}=p(t.get(F),D);if(E||P)if(g===n.Kind.FRAGMENT_SPREAD&&C){const e=y[C];e&&(e.hasData+=1)}else i.hasChildFields(f,{fragmentDefinitions:o})?u(f,t,s,F,h)&&i.deleteChildFields(e,f):i.deleteChildFields(e,f)}return((e,t,a,s)=>{if(!r.isEmpty(t))for(const n of Object.keys(t)){const r=a[n];if(!r)continue;r.paths.push(s);const{hasData:c,total:h}=t[n];c===h&&(i.deleteFragmentSpreads(e,n),r.deleted+=1)}})(e,y,s,c),((e,{fragmentDefinitions:t,typeIDKey:a})=>{const s=i.getInlineFragments(e);let n=!1;for(const r of s){const s=i.getChildFields(r,{fragmentDefinitions:t});if(!s||0===s.length){i.deleteInlineFragments(e,r),n=!0;continue}const[c]=s;if(c){const{fieldNode:t}=c;i.getName(t)===a&&(i.deleteInlineFragments(e,r),n=!0)}}})(e,h),((e,{fragmentDefinitions:t,typeIDKey:s})=>{const n=i.getChildFields(e,{fragmentDefinitions:t});if(!n||n.length>3)return!1;const r=n.map((({fieldNode:e})=>i.getName(e)));if(2===r.length&&r.every((e=>e===s||e===a.TYPE_NAME_KEY)))return i.deleteChildFields(e,n.map((({fieldNode:e})=>e))),!0;if(1===r.length&&r[0]===s||r[0]===a.TYPE_NAME_KEY){const[t]=n;if(t){const{fieldNode:a}=t;return i.deleteChildFields(e,a),!0}}})(e,h),!i.hasChildFields(e,{fragmentDefinitions:o})},_=(e,{fieldPathChecklist:t},a)=>{const{ast:s}=e,n=i.getOperationDefinitions(s,a.operation)[0];if(!n)return s;const{fragmentDefinitions:c,operation:h}=a,o=i.getChildFields(n,{fragmentDefinitions:c});if(!o)return s;const d=(({request:e},{fragmentDefinitions:t})=>r.keys(t??{}).reduce(((t,a)=>(t[a]={deleted:0,paths:[],total:(e.match(new RegExp(`\\.\\.\\.${a}`,"g"))??[]).length},t)),{}))(e,a);for(let e=o.length-1;e>=0;e-=1){const{fieldNode:s}=o[e],{requestFieldPath:r}=i.buildFieldKeysAndPaths(s,{requestFieldPath:h},a);u(s,t,d,r,a)&&i.deleteChildFields(n,s)}return a.queryFiltered=!0,((e,t,a,s)=>{const n=r.keys(a).reduce(((e,t)=>{const i=a[t];if(!i)return e;const{deleted:s,paths:n,total:r}=i;return 0===s&&1===r?[...e,{name:t,path:n[0]}]:e}),[]),{fragmentDefinitions:c={}}=s;for(const{name:e,path:i}of n){const n=c[e];n&&u(n,t,a,i,s)}const h=r.keys(a).reduce(((e,t)=>{const i=a[t];if(!i)return e;const{deleted:s,total:n}=i;return s>0&&s===n?[...e,t]:e}),[]);return 0===h.length?e:i.deleteFragmentDefinitions(e,{include:h})})(s,t,d,a)},f=(e,t)=>i.isArray(e)&&r.isNumber(t)||i.isPlainObject(e)&&r.isString(t)?e[t]:void 0,g=e=>!!i.isObjectLike(e)&&(a.TYPE_NAME_KEY in e&&r.isString(e[a.TYPE_NAME_KEY]));var C,D,m,F;let E=(C=(e,t,i)=>{const s=i.value;s&&(i.value=async function(...e){return new Promise((t=>{(async()=>{const{debugManager:i,requestFieldCacheKey:n,...r}=e[3];if(!i)return void t(await s.apply(this,e));const c=i.now(),h=await s.apply(this,e),o=i.now(),d=o-c;t(h);const l={cacheType:e[0],context:r,options:e[2],requestHash:e[1],result:h,stats:{duration:d,endTime:o,startTime:c},...n?{decryptedCacheKey:n}:{}};i.log(a.CACHE_ENTRY_QUERIED,l)})()}))})},D=(e,t,i)=>{const s=i.value;s&&(i.value=async function(...e){return new Promise((t=>{(async()=>{const{debugManager:i,requestFieldCacheKey:n,...r}=e[5];if(!i)return await s.apply(this,e),void t();const c=i.now();await s.apply(this,e);const h=i.now(),o=h-c;t();const d={cacheType:e[0],cachemapOptions:e[3],context:r,options:e[4],requestHash:e[1],stats:{duration:o,endTime:h,startTime:c},value:e[2],...n?{decryptedCacheKey:n}:{}};i.log(a.CACHE_ENTRY_ADDED,d)})()}))})},m=(e,t,i)=>{const s=i.value;s&&(i.value=function(...e){const{debugManager:t,...i}=e[3];if(!t)return void s.apply(this,e);const n=t.now();s.apply(this,e);const r=t.now(),c=r-n;t.log(a.PARTIAL_QUERY_COMPILED,{context:i,options:e[2],requestHash:e[0],result:e[1],stats:{duration:c,endTime:r,startTime:n}})})},F=class t{static _countFieldPathChecklist(e){const t={missing:0,total:0};for(const[,a]of e){t.total+=a.length;const e=a.filter((({hasData:e})=>!e));t.missing+=e.length}return t}static _getFieldDataFromAncestor(e,t){const a=f(e,t);return i.isObjectLike(a)?r.cloneDeep(a):a}static _getOperationCacheControl(e,t){const a="no-cache";if(!e)return a;const i=e.get(t);return i?i.printCacheControl():a}static _isNodeEntity(e){if(!e)return!1;const{isEntity:t,possibleTypes:a}=e;return t||a.some((e=>!!e.isEntity))}static _isNodeRequestFieldPath(e){return!!e&&(this._isNodeEntity(e)||e.hasArguments||e.hasDirectives)}static _isValid(e){return!r.get(e,["metadata","cacheControl",c],!1)&&e.checkTTL()}static _mergeResponseCacheMetadata(e,t){return t?new Map([...t.cacheMetadata,...e]):e}static _setCachedData(e,{data:t},a){const s=t=>{(i.isArray(e)&&r.isNumber(a)||i.isPlainObject(e))&&(e[a]=t)};i.isObjectLike(t)||r.isUndefined(t)?i.isArray(t)?s([]):i.isPlainObject(t)&&s({}):s(t)}static _setCachedResponseData(e,{cacheMetadata:a,data:i,fieldPathChecklist:s},{propNameOrIndex:n,requestFieldPath:r},c,h,{operation:o}){t._setCacheMetadata(a,e.cacheability,r,o),t._setFieldPathChecklist(s,e,r,c),t._setCachedData(i,e,n)}static _setCacheMetadata(e,t,a,i){if(!t)return;e.set(a,t);const s=e.get(i);(!s||s.metadata.ttl>t.metadata.ttl)&&e.set(i,t)}static _setFieldPathChecklist(e,{data:t},a,{dataTypename:i,fieldTypename:s,fragmentKind:c,fragmentName:h}){if(r.isUndefined(s)||c===n.Kind.FRAGMENT_SPREAD){if(e.has(a))return;return void e.set(a,[{fragmentKind:c,fragmentName:h,hasData:!r.isUndefined(t)}])}if(i!==s)return;const o=e.get(a)??[];o.some((({typeName:e})=>e===i))||e.set(a,[...o,{fragmentKind:c,fragmentName:h,hasData:!r.isUndefined(t),typeName:i}])}constructor(t){e(this,"_cache",void 0),e(this,"_cascadeCacheControl",void 0),e(this,"_fallbackOperationCacheability",void 0),e(this,"_partialQueryResponses",new Map),e(this,"_responseChunksAwaitingCaching",new Map),e(this,"_typeCacheDirectives",void 0),e(this,"_typeIDKey",void 0);const s=[];if("cache"in t||s.push(new i.ArgsError("@graphql-box/cache-manager expected cache to be in options.")),t.typeCacheDirectives&&!i.isPlainObject(t.typeCacheDirectives)){const e="@graphql-box/cache-manager expected options.typeCacheDirectives to be a plain object.";s.push(new i.ArgsError(e))}if(s.length>0)throw new i.GroupedError("@graphql-box/cache-manager argument validation errors.",s);this._cache=t.cache,this._cascadeCacheControl=t.cascadeCacheControl??!1,this._fallbackOperationCacheability=t.fallbackOperationCacheability??c,this._typeCacheDirectives=t.typeCacheDirectives??{},this._typeIDKey=t.typeIDKey??a.DEFAULT_TYPE_ID_KEY}async analyzeQuery(e,t,a){const{ast:s,hash:c}=e,h={...a,fragmentDefinitions:i.getFragmentDefinitions(s),typeIDKey:this._typeIDKey},d=await this._retrieveCachedResponseData(e,t,h),{cacheMetadata:l,data:y,fieldCount:p}=d;if(p.missing===p.total||((e,t)=>o(e,t))(y,this._typeIDKey))return{updated:e};if(!p.missing){const e=this._setQueryResponseCacheEntry(c,{cacheMetadata:l,data:y},t,h);return t.awaitDataCaching&&await e,{response:{cacheMetadata:l,data:y}}}const u=_(e,d,h),f=n.print(u),{fragmentDefinitions:g,typeIDKey:C,...D}=h;return r.assign(a,{...D,filteredRequest:f}),this._setPartialQueryResponse(c,{cacheMetadata:l,data:y},t,a),{updated:{ast:u,hash:i.hashRequest(f),request:f}}}get cache(){return this._cache}async cacheQuery(e,t,a,s,n){const r={...n,fragmentDefinitions:i.getFragmentDefinitions((t??e).ast),typeIDKey:this._typeIDKey};return this._cacheResponse(e,t,a,s,r)}async cacheResponse(e,t,a,s){const n={...s,fragmentDefinitions:i.getFragmentDefinitions(e.ast),typeIDKey:this._typeIDKey};return this._cacheResponse(e,void 0,t,a,n)}async checkCacheEntry(e,t,a,i){return this._checkCacheEntry(e,t,a,i)}async checkQueryResponseCacheEntry(e,t,s){const n=await this._checkCacheEntry(a.QUERY_RESPONSES,e,t,s);if(!n)return!1;const{cacheMetadata:r,data:c}=n.entry;return{cacheMetadata:i.rehydrateCacheMetadata(r),data:c}}deletePartialQueryResponse(e){this._partialQueryResponses.delete(e)}async setQueryResponseCacheEntry(e,t,a,i){return this._setQueryResponseCacheEntry(e.hash,t,a,i)}async _analyzeFieldNode(e,t,a,s,n){await(i.hasChildFields(e,{fragmentDefinitions:n.fragmentDefinitions})?this._analyzeParentFieldNode(e,t,a,s,n):this._analyzeLeafFieldNode(e,t,a,s,n))}async _analyzeLeafFieldNode(e,a,s,n,r){const c=i.buildFieldKeysAndPaths(e,a,r),{hashedRequestFieldCacheKey:h,propNameOrIndex:o,requestFieldCacheKey:d,requestFieldPath:l}=c,y=r.fieldTypeMap.get(l),{entityData:p,fragmentKind:u,fragmentName:_,requestFieldPathData:f,typeName:C}=a,D={dataTypename:g(p)?p.__typename:g(f)?f.__typename:void 0,fieldTypename:C,fragmentKind:u,fragmentName:_};if(t._isNodeRequestFieldPath(y)){const{cacheability:e,entry:a}=await this._retrieveCachedRequestFieldPathData(h,d,n,r);t._setCachedResponseData({cacheability:e,data:a},s,c,D,n,r)}else{const e=t._getFieldDataFromAncestor(p,o)??t._getFieldDataFromAncestor(f,o);t._setFieldPathChecklist(s.fieldPathChecklist,{data:e},l,D),t._setCachedData(s.data,{data:e},o)}}async _analyzeParentFieldNode(e,s,n,c,h){const o=i.buildFieldKeysAndPaths(e,s,h),{propNameOrIndex:d,requestFieldCacheKey:l,requestFieldPath:y}=o,p=h.fieldTypeMap.get(y),{cacheability:u,data:_,entityData:g,requestFieldPathData:C}=await this._retrieveCachedParentNodeData(s,o,p,c,h),{fragmentKind:D,fragmentName:m,typeName:F}=s;if(t._setCachedResponseData({cacheability:u,data:_},n,o,{dataTypename:r.get(_,a.TYPE_NAME_KEY),fieldTypename:F,fragmentKind:D,fragmentName:m},c,h),!i.isObjectLike(_))return;const E=[];i.iterateChildFields(e,_,h.fragmentDefinitions,((e,t,a,i,s)=>{E.push(this._analyzeFieldNode(e,{cacheability:u,entityData:g,fragmentKind:a,fragmentName:i,index:s,requestFieldCacheKey:l,requestFieldPath:y,requestFieldPathData:C,typeName:t},{...n,data:f(n.data,d)},c,h))})),await Promise.all(E)}_buildCacheMetadata({ast:e},{data:t,...a},s,n){const r=this._createCacheMetadata({data:t,...a},n),c=i.getOperationDefinitions(e,n.operation)[0];if(!c)return r;const h=i.getChildFields(c);if(!h)return r;for(const{fieldNode:e}of h)this._setFieldCacheability(e,{requestFieldPath:n.operation},{cacheMetadata:r,data:t},s,n);return r}async _cacheResponse(e,a,i,s,c){const h=((e,t)=>{if(!t.normalizePatchResponseData)return e;const{data:a,paths:i,...s}=e;return i?.length&&r.isString(i[0])?{...s,data:r.set({},i[0],a),paths:i}:e})(i,c);let o=h;((e,t)=>t.hasDeferOrStream&&e.hasNext)(i,c)&&(this._setResponseChunksAwaitingCaching(h,c),o=void 0),((e,t)=>t.hasDeferOrStream&&!e.hasNext&&e.paths)(i,c)&&(o=this._retrieveResponseDataForCaching(h,c));const d=[];if(o){const{data:i}=o,l=this._buildCacheMetadata(e,o,s,c);let y,p;if(d.push(this._setEntityAndRequestFieldPathCacheEntries(e,{cacheMetadata:l,entityData:r.cloneDeep(i),requestFieldPathData:r.cloneDeep(i)},s,c)),c.operation===n.OperationTypeNode.QUERY){let n;c.queryFiltered&&a&&(d.push(this._setQueryResponseCacheEntry(a.hash,{cacheMetadata:l,data:i},s,c)),n=this._getPartialQueryResponse(e.hash)),y=t._mergeResponseCacheMetadata(l,n),p=this._mergeResponseData(i,n),d.push(this._setQueryResponseCacheEntry(e.hash,{cacheMetadata:y,data:p},s,c))}if(s.awaitDataCaching&&await Promise.all(d),((e,t)=>!t.hasDeferOrStream&&!e.hasNext&&!e.paths)(h,c)&&y&&p)return{cacheMetadata:y,data:p}}const{data:l,hasNext:y,paths:p}=h;return{cacheMetadata:this._buildCacheMetadata(e,h,s,c),data:l,hasNext:y,paths:p}}async _checkCacheEntry(e,a,i,s){try{const n=await this._hasCacheEntry(e,a);if(!n||!t._isValid(n))return!1;const c=await this._getCacheEntry(e,a,i,s);return!r.isUndefined(c)&&{cacheability:n,entry:c}}catch{return!1}}_createCacheMetadata({_cacheMetadata:e,headers:t},{operation:a}){const s=new Map,n=y({_cacheMetadata:e,fallback:this._fallbackOperationCacheability,headers:t});return s.set(a,n),e&&i.rehydrateCacheMetadata(e,s),s}async _getCacheEntry(e,t,a,i){return this._cache.get(`${e}::${t}`)}_getPartialQueryResponse(e){const t=this._partialQueryResponses.get(e);return this._partialQueryResponses.delete(e),t}async _hasCacheEntry(e,t){try{return await this._cache.has(`${e}::${t}`)}catch{return!1}}_isFieldEntity(e,{isEntity:t,possibleTypes:a}){return!(!i.isPlainObject(e)||!(this._typeIDKey in e))&&(!!t||0!==a.length&&a.some((t=>t.typeName===e.__typename)))}_mergeResponseData(e,t){return t?d(t.data,e,this._typeIDKey):e}async _parseEntityAndRequestFieldPathCacheEntryData(e,t,{cacheMetadata:a,entityData:s,requestFieldPathData:n},c,h){const o=i.buildFieldKeysAndPaths(e,t,h),{requestFieldCacheKey:d,requestFieldPath:l,responseDataPath:y}=o,p=r.get(n,y),u=h.fieldTypeMap.get(l);if(i.isObjectLike(p)||u?.hasDirectives){if(i.isObjectLike(p)){const t=[];i.iterateChildFields(e,p,h.fragmentDefinitions,((e,i,r,o,p)=>{t.push(this._parseEntityAndRequestFieldPathCacheEntryData(e,{index:p,requestFieldCacheKey:d,requestFieldPath:l,responseDataPath:y},{cacheMetadata:a,entityData:s,requestFieldPathData:n},c,h))})),await Promise.all(t)}await this._setEntityAndRequestFieldPathCacheEntry(e,o,{cacheMetadata:a,entityData:s,requestFieldPathData:n},c,h)}}async _retrieveCachedEntityData(e,{possibleTypes:t,typeName:i},s,n){const r=[...t.map((e=>e.typeName)),i],c=(await Promise.all(r.map((t=>this._checkCacheEntry(a.DATA_ENTITIES,`${t}::${e}`,s,n))))).filter((e=>!!e));let h;return 1===c.length?h=c[0]:c.length>1&&(c.sort((({cacheability:e},{cacheability:t})=>e.metadata.ttl-t.metadata.ttl)),h={cacheability:c[0].cacheability,entry:c.reduce(((e,{entry:t})=>d(e,t,this._typeIDKey)),{})}),h??{}}async _retrieveCachedParentNodeData({entityData:e,requestFieldPathData:a},{hashedRequestFieldCacheKey:s,propNameOrIndex:n,requestFieldCacheKey:c},h,o,d){let y,p=t._getFieldDataFromAncestor(e,n),u=t._getFieldDataFromAncestor(a,n);if(t._isNodeRequestFieldPath(h)){const{cacheability:e,entry:t}=await this._retrieveCachedRequestFieldPathData(s,c,o,d);u=l(u,t,this._typeIDKey),e&&(y=e)}const _=((e,{typeIDValue:t},a)=>t||(i.isPlainObject(e)?e[a]:void 0))(u,h,this._typeIDKey);if(t._isNodeEntity(h)&&_){const{cacheability:e,entry:t}=await this._retrieveCachedEntityData(_,h,o,d);p=l(p,t,this._typeIDKey),e&&(!y||e.metadata.ttl>y.metadata.ttl)&&(y=e)}return{cacheability:y,data:r.isEqual(p,u)?p:l(p,u,this._typeIDKey),entityData:p,requestFieldPathData:u}}async _retrieveCachedRequestFieldPathData(e,t,i,s){return await this._checkCacheEntry(a.REQUEST_FIELD_PATHS,e,i,{...s,requestFieldCacheKey:t})||{}}async _retrieveCachedResponseData({ast:e},a,s){const n={cacheMetadata:new Map,data:{},fieldCount:{missing:0,total:0},fieldPathChecklist:new Map},r=i.getOperationDefinitions(e,s.operation)[0];if(!r)return n;const c=i.getChildFields(r);return c?(await Promise.all(c.map((({fieldNode:e})=>this._analyzeFieldNode(e,{requestFieldPath:s.operation},n,a,s)))),n.fieldCount=t._countFieldPathChecklist(n.fieldPathChecklist),n):n}_retrieveResponseDataForCaching(e,t){const a=this._responseChunksAwaitingCaching.get(t.requestID);return this._responseChunksAwaitingCaching.delete(t.requestID),(i=[...a,e]).reduce(((e,t,a)=>{const{_cacheMetadata:s,data:n,hasNext:c,headers:h,paths:o}=t;return s&&(e._cacheMetadata=e._cacheMetadata?{...e._cacheMetadata,...s}:s),e.data=r.merge(e.data,n),0===a&&(e.headers=h),a===i.length-1&&(e.hasNext=c),o&&(e.paths||(e.paths=[]),e.paths.push(...o)),e}),{data:{}});var i}async _setCacheEntry(e,t,a,i,s,n){try{await this._cache.set(`${e}::${t}`,r.cloneDeep(a),i)}catch{}}async _setEntityAndRequestFieldPathCacheEntries(e,t,a,s){const n=i.getOperationDefinitions(e.ast,s.operation)[0];if(!n)return;const r=i.getChildFields(n);r&&await Promise.all(r.map((({fieldNode:e})=>this._parseEntityAndRequestFieldPathCacheEntryData(e,{requestFieldPath:s.operation},t,a,s))))}async _setEntityAndRequestFieldPathCacheEntry(e,t,{cacheMetadata:a,entityData:i,requestFieldPathData:s},n,c){const{requestFieldPath:h,responseDataPath:o}=t,d=r.get(i,o),l=c.fieldTypeMap.get(h),y=a.get(h);if(r.isUndefined(d)||!l||!y)return;const p=[];p.push(this._setRequestFieldPathCacheEntry(e,t,{cacheability:y,data:s,fieldTypeInfo:l},n,c));const u=this._isFieldEntity(d,l);!u&&l.hasArguments&&r.unset(i,o),u&&p.push(this._setEntityCacheEntry(t,{cacheability:y,data:i,fieldTypeInfo:l},n,c)),await Promise.all(p)}async _setEntityCacheEntry({responseDataPath:e},{cacheability:t,data:i,fieldTypeInfo:s},n,c){let h=r.get(i,e);const o=`${s.isEntity?s.typeName:h.__typename}::${String(h[this._typeIDKey])}`,l=await this._checkCacheEntry(a.DATA_ENTITIES,o,n,c);l&&(h=d(l.entry,h,this._typeIDKey)),await this._setCacheEntry(a.DATA_ENTITIES,o,h,{cacheHeaders:{cacheControl:t.printCacheControl()},tag:n.tag},n,c),r.set(i,e,{__cacheKey:`${a.DATA_ENTITIES}::${o}`})}_setFieldCacheability(e,t,{cacheMetadata:a,data:s},n,c){const{requestFieldPath:h}=t,o=i.buildFieldKeysAndPaths(e,t,c),{requestFieldPath:d,responseDataPath:l}=o;if(!i.isObjectLike(s))return;const y=r.get(s,l),p=c.fieldTypeMap.get(d);(i.isObjectLike(y)||p?.hasDirectives)&&(this._setFieldTypeCacheDirective(a,{ancestorRequestFieldPath:h,requestFieldPath:d},c),i.isObjectLike(y)&&i.iterateChildFields(e,y,c.fragmentDefinitions,((e,t,i,r,h)=>{this._setFieldCacheability(e,{index:h,requestFieldPath:d,responseDataPath:l},{cacheMetadata:a,data:s},n,c)})))}_setFieldTypeCacheDirective(e,{ancestorRequestFieldPath:a,requestFieldPath:i},{fieldTypeMap:n,operation:r}){if(e.has(i))return;const c=n.get(i);if(c&&this._typeCacheDirectives[c.typeName]){const a=new s.Cacheability({cacheControl:this._typeCacheDirectives[c.typeName]});t._setCacheMetadata(e,a,i,r)}else this._cascadeCacheControl&&a&&t._setCacheMetadata(e,e.get(a),i,r)}_setPartialQueryResponse(e,t,a,i){this._partialQueryResponses.set(e,t)}async _setQueryResponseCacheEntry(e,{cacheMetadata:s,data:n},r,c){const h=i.dehydrateCacheMetadata(s),o=t._getOperationCacheControl(s,c.operation);await this._setCacheEntry(a.QUERY_RESPONSES,e,{cacheMetadata:h,data:n},{cacheHeaders:{cacheControl:o},tag:r.tag},r,c)}async _setRequestFieldPathCacheEntry(e,t,{cacheability:s,data:c,fieldTypeInfo:h},o,l){const{hashedRequestFieldCacheKey:y,requestFieldCacheKey:p,responseDataPath:u}=t;let _=r.get(c,u);const f=this._isFieldEntity(_,h),g=h.hasArguments||h.hasDirectives;if(l.operation===n.OperationTypeNode.QUERY&&(f||g)){i.isPlainObject(_)&&e.selectionSet?.selections&&(_=((e,t,a,s)=>{const n=i.resolveFragments(t,s.fragmentDefinitions);return r.keys(e).reduce(((t,r)=>{const c=n.find((({fieldNode:e})=>i.getName(e)===r));if(c){const{requestFieldPath:n}=i.buildFieldKeysAndPaths(c.fieldNode,a,s),h=s.fieldTypeMap.get(n);h?.hasArguments||h?.hasDirectives||(t[r]=e[r])}return t}),{})})(_,e.selectionSet.selections,t,l));const n=await this._checkCacheEntry(a.REQUEST_FIELD_PATHS,y,o,{...l,requestFieldCacheKey:p});n&&i.isObjectLike(n.entry)&&i.isObjectLike(_)&&(_=d(n.entry,_,this._typeIDKey)),await this._setCacheEntry(a.REQUEST_FIELD_PATHS,y,_,{cacheHeaders:{cacheControl:s.printCacheControl()},tag:o.tag},o,{...l,requestFieldCacheKey:p}),i.hasChildFields(e,{fragmentDefinitions:l.fragmentDefinitions})&&(f?r.set(c,u,{__cacheKey:`${a.REQUEST_FIELD_PATHS}::${y}`}):r.unset(c,u))}}_setResponseChunksAwaitingCaching(e,t){const a=this._responseChunksAwaitingCaching.get(t.requestID);a?this._responseChunksAwaitingCaching.set(t.requestID,[...a,e]):this._responseChunksAwaitingCaching.set(t.requestID,[e])}},t(F.prototype,"_getCacheEntry",[C],Object.getOwnPropertyDescriptor(F.prototype,"_getCacheEntry"),F.prototype),t(F.prototype,"_setCacheEntry",[D],Object.getOwnPropertyDescriptor(F.prototype,"_setCacheEntry"),F.prototype),t(F.prototype,"_setPartialQueryResponse",[m],Object.getOwnPropertyDescriptor(F.prototype,"_setPartialQueryResponse"),F.prototype),F);exports.CacheManager=E;
 //# sourceMappingURL=index.cjs.map