@graphql-box/cache-manager 5.0.0 → 5.0.2

package/dist/esm/index.mjs

@@ -1,1475 +1,2 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _applyDecoratedDescriptor from '@babel/runtime/helpers/applyDecoratedDescriptor';
-import 'core-js/modules/es.array.push.js';
-import { CACHE_ENTRY_ADDED, CACHE_ENTRY_QUERIED, PARTIAL_QUERY_COMPILED, TYPE_NAME_KEY, DEFAULT_TYPE_ID_KEY, QUERY_RESPONSES, DATA_ENTITIES, REQUEST_FIELD_PATHS } from '@graphql-box/core';
-import { isPlainObject, isArray, mergeObjects, isObjectLike, resolveFragments, getName, buildFieldKeysAndPaths, deleteFragmentSpreads, getChildFields, deleteChildFields, getInlineFragments, deleteInlineFragments, hasChildFields, deleteFragmentDefinitions, getOperationDefinitions, ArgsError, GroupedError, getFragmentDefinitions, hashRequest, rehydrateCacheMetadata, iterateChildFields, dehydrateCacheMetadata } from '@graphql-box/helpers';
-import { Cacheability } from 'cacheability';
-import { Kind, print, OperationTypeNode } from 'graphql';
-import { isNumber, isString, isEmpty, keys, merge, set, cloneDeep, get, isUndefined, assign, isEqual, unset } from '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(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(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(PARTIAL_QUERY_COMPILED, {
-        context: otherContext,
-        options: args[2],
-        requestHash: args[0],
-        result: args[1],
-        stats: {
-          duration,
-          endTime,
-          startTime
-        }
-      });
-    };
-  };
-};
-
-const checkValue = (value, typeIDKey) => {
-  if (isArray(value)) {
-    return value.reduce((acc, entry) => {
-      if (!acc) {
-        return false;
-      }
-      return checkValue(entry, typeIDKey);
-    }, true);
-  }
-  if (isPlainObject(value)) {
-    return recursivelyCheckProps(value, typeIDKey);
-  }
-  return false;
-};
-const recursivelyCheckProps = (data, typeIDKey) => {
-  const keys = isPlainObject(data) ? Object.keys(data) : [...data.keys()];
-  if (keys.length === 1 && isPlainObject(data) && !!data[typeIDKey]) {
-    return true;
-  }
-  return keys.reduce((acc, key) => {
-    if (!acc) {
-      return false;
-    }
-    if (isNumber(key) && isArray(data)) {
-      return checkValue(data[key], typeIDKey);
-    } else if (isString(key) && isPlainObject(data)) {
-      return checkValue(data[key], typeIDKey);
-    }
-    return acc;
-  }, true);
-};
-const areOnlyPopulatedFieldsTypeIdKeys = (data, typeIDKey) => {
-  return recursivelyCheckProps(data, typeIDKey);
-};
-
-const mergeDataSets = (obj, source, typeIDKey) => {
-  return mergeObjects(obj, source, (_key, value) => {
-    return isPlainObject(value) && value[typeIDKey] ? value[typeIDKey] : undefined;
-  });
-};
-
-const combineDataSets = (dataSetA, dataSetB, typeIDKey) => {
-  if (!dataSetA && dataSetB) {
-    return dataSetB;
-  }
-  if (isObjectLike(dataSetA) && isObjectLike(dataSetB)) {
-    return mergeDataSets(dataSetA, dataSetB, typeIDKey);
-  }
-  return dataSetA;
-};
-
-const deriveOpCacheability = ({
-  _cacheMetadata,
-  fallback,
-  headers
-}) => {
-  if (_cacheMetadata && !isEmpty(_cacheMetadata)) {
-    const [first, ...rest] = Object.values(_cacheMetadata);
-    return new 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({
-      headers
-    });
-  }
-  return new Cacheability({
-    cacheControl: fallback
-  });
-};
-
-const filterOutPropsWithArgsOrDirectives = (fieldData, selectionNodes, ancestorKeysAndPaths, context) => {
-  const fieldAndTypeName = resolveFragments(selectionNodes, context.fragmentDefinitions);
-  return keys(fieldData).reduce((acc, key) => {
-    const match = fieldAndTypeName.find(({
-      fieldNode
-    }) => getName(fieldNode) === key);
-    if (match) {
-      const {
-        requestFieldPath
-      } = 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
-}) => 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 (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) {
-      deleteFragmentSpreads(field, key);
-      checklist.deleted += 1;
-    }
-  }
-};
-
-const filterIDsAndTypeNames = (field, {
-  fragmentDefinitions,
-  typeIDKey
-}) => {
-  const fieldsAndTypeNames = getChildFields(field, {
-    fragmentDefinitions
-  });
-  if (!fieldsAndTypeNames || fieldsAndTypeNames.length > 3) {
-    return false;
-  }
-  const fieldNames = fieldsAndTypeNames.map(({
-    fieldNode
-  }) => getName(fieldNode));
-  if (fieldNames.length === 2 && fieldNames.every(name => name === typeIDKey || name === TYPE_NAME_KEY)) {
-    deleteChildFields(field, fieldsAndTypeNames.map(({
-      fieldNode
-    }) => fieldNode));
-    return true;
-  }
-  if (fieldNames.length === 1 && fieldNames[0] === typeIDKey || fieldNames[0] === TYPE_NAME_KEY) {
-    const [fieldAndTypeName] = fieldsAndTypeNames;
-    if (fieldAndTypeName) {
-      const {
-        fieldNode
-      } = fieldAndTypeName;
-      deleteChildFields(field, fieldNode);
-      return true;
-    }
-  }
-  return false;
-};
-
-const filterInlineFragments = (field, {
-  fragmentDefinitions,
-  typeIDKey
-}) => {
-  const inlineFragments = getInlineFragments(field);
-  let filtered = false;
-  for (const fragment of inlineFragments) {
-    const fieldsAndTypeNames = getChildFields(fragment, {
-      fragmentDefinitions
-    });
-    if (!fieldsAndTypeNames || fieldsAndTypeNames.length === 0) {
-      deleteInlineFragments(field, fragment);
-      filtered = true;
-      continue;
-    }
-    const [fieldAndTypeName] = fieldsAndTypeNames;
-    if (fieldAndTypeName) {
-      const {
-        fieldNode
-      } = fieldAndTypeName;
-      if (getName(fieldNode) === typeIDKey) {
-        deleteInlineFragments(field, fragment);
-        filtered = true;
-      }
-    }
-  }
-  return filtered;
-};
-
-const filterField = (field, fieldPathChecklist, fragmentSpreadChecklist, ancestorRequestFieldPath, context) => {
-  const {
-    fragmentDefinitions,
-    typeIDKey
-  } = context;
-  const fieldsAndTypeNames = 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 === Kind.FRAGMENT_SPREAD && fragmentName && !fragmentSpreadFieldCounter[fragmentName]) {
-      fragmentSpreadFieldCounter[fragmentName] = {
-        hasData: 0,
-        total: fragmentDefinitions?.[fragmentName] ? getChildFields(fragmentDefinitions[fragmentName], {
-          fragmentDefinitions
-        })?.length ?? 0 : 0
-      };
-    }
-    const childFieldName = getName(childField);
-    if (childFieldName === typeIDKey || childFieldName === TYPE_NAME_KEY) {
-      continue;
-    }
-    const {
-      requestFieldPath
-    } = buildFieldKeysAndPaths(childField, {
-      requestFieldPath: ancestorRequestFieldPath
-    }, context);
-    const {
-      hasData,
-      typeUnused
-    } = checkFieldPathChecklist(fieldPathChecklist.get(requestFieldPath), childTypeName);
-    if (hasData || typeUnused) {
-      if (fragmentKind === Kind.FRAGMENT_SPREAD && fragmentName) {
-        const counter = fragmentSpreadFieldCounter[fragmentName];
-        if (counter) {
-          counter.hasData += 1;
-        }
-      } else if (!hasChildFields(childField, {
-        fragmentDefinitions
-      })) {
-        deleteChildFields(field, childField);
-      } else if (filterField(childField, fieldPathChecklist, fragmentSpreadChecklist, requestFieldPath, context)) {
-        deleteChildFields(field, childField);
-      }
-    }
-  }
-  filterFragmentSpreads(field, fragmentSpreadFieldCounter, fragmentSpreadChecklist, ancestorRequestFieldPath);
-  filterInlineFragments(field, context);
-  filterIDsAndTypeNames(field, context);
-  return !hasChildFields(field, {
-    fragmentDefinitions
-  });
-};
-
-const filterFragmentDefinitions = (ast, fieldPathChecklist, fragmentSpreadChecklist, context) => {
-  const definitionsToFilter = 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 = 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 deleteFragmentDefinitions(ast, {
-    include: definitionsToDelete
-  });
-};
-
-const filterQuery = (requestData, {
-  fieldPathChecklist
-}, context) => {
-  const {
-    ast
-  } = requestData;
-  const queryNode = getOperationDefinitions(ast, context.operation)[0];
-  if (!queryNode) {
-    return ast;
-  }
-  const {
-    fragmentDefinitions,
-    operation
-  } = context;
-  const fieldsAndTypeNames = 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
-    } = buildFieldKeysAndPaths(fieldNode, {
-      requestFieldPath: operation
-    }, context);
-    if (filterField(fieldNode, fieldPathChecklist, fragmentSpreadChecklist, requestFieldPath, context)) {
-      deleteChildFields(queryNode, fieldNode);
-    }
-  }
-  context.queryFiltered = true;
-  return filterFragmentDefinitions(ast, fieldPathChecklist, fragmentSpreadChecklist, context);
-};
-
-const getDataValue = (value, key) => {
-  if (isArray(value) && isNumber(key)) {
-    return value[key];
-  }
-  if (isPlainObject(value) && isString(key)) {
-    return value[key];
-  }
-  return;
-};
-
-const hasTypename = value => {
-  if (!isObjectLike(value)) {
-    return false;
-  }
-  return TYPE_NAME_KEY in value && isString(value[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 = 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 || !isString(paths[0])) {
-    return rawResponseData;
-  }
-  return {
-    ...rest,
-    data: set({}, paths[0], data),
-    paths
-  };
-};
-
-const getValidTypeIdValue = (requestFieldPathData, {
-  typeIDValue
-}, typeIDKey) => {
-  if (typeIDValue) {
-    return typeIDValue;
-  }
-  if (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 isObjectLike(dataValue) ? 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 = 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 (isArray(responseData) && isNumber(propNameOrIndex)) {
-        responseData[propNameOrIndex] = value;
-      } else if (isPlainObject(responseData)) {
-        responseData[propNameOrIndex] = value;
-      }
-    };
-    if (!isObjectLike(data) && !isUndefined(data)) {
-      setData(data);
-    } else if (isArray(data)) {
-      setData([]);
-    } else if (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 (isUndefined(fieldTypeName) || fragmentKind === Kind.FRAGMENT_SPREAD) {
-      if (fieldPathChecklist.has(requestFieldPath)) {
-        return;
-      }
-      fieldPathChecklist.set(requestFieldPath, [{
-        fragmentKind,
-        fragmentName,
-        hasData: !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: !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 ArgsError('@graphql-box/cache-manager expected cache to be in options.'));
-    }
-    if (!!options.typeCacheDirectives && !isPlainObject(options.typeCacheDirectives)) {
-      const message = '@graphql-box/cache-manager expected options.typeCacheDirectives to be a plain object.';
-      errors.push(new ArgsError(message));
-    }
-    if (errors.length > 0) {
-      throw new 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 ?? DEFAULT_TYPE_ID_KEY;
-  }
-  async analyzeQuery(requestData, options, context) {
-    const {
-      ast,
-      hash
-    } = requestData;
-    const cacheManagerContext = {
-      ...context,
-      fragmentDefinitions: 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 = print(filteredAST);
-    const {
-      fragmentDefinitions,
-      typeIDKey,
-      ...rest
-    } = cacheManagerContext;
-    assign(context, {
-      ...rest,
-      filteredRequest
-    });
-    this._setPartialQueryResponse(hash, {
-      cacheMetadata,
-      data
-    }, options, context);
-    return {
-      updated: {
-        ast: filteredAST,
-        hash: hashRequest(filteredRequest),
-        request: filteredRequest
-      }
-    };
-  }
-  get cache() {
-    return this._cache;
-  }
-  async cacheQuery(requestData, updatedRequestData, rawResponseData, options, context) {
-    const cacheManagerContext = {
-      ...context,
-      fragmentDefinitions: 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: 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(QUERY_RESPONSES, hash, options, context);
-    if (!result) {
-      return false;
-    }
-    const {
-      cacheMetadata,
-      data
-    } = result.entry;
-    return {
-      cacheMetadata: 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 (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 = 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 = 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: get(data, TYPE_NAME_KEY),
-      fieldTypename: typeName,
-      fragmentKind,
-      fragmentName
-    }, options, context);
-    if (!isObjectLike(data)) {
-      return;
-    }
-    const promises = [];
-    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 = getOperationDefinitions(ast, context.operation)[0];
-    if (!queryNode) {
-      return cacheMetadata;
-    }
-    const fieldsAndTypeNames = 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: cloneDeep(data),
-        requestFieldPathData: cloneDeep(data)
-      }, options, context));
-      let queryCacheMetadata;
-      let queryData;
-      if (context.operation === 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 (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) {
-      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 (!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 = buildFieldKeysAndPaths(field, ancestorKeysAndPaths, context);
-    const {
-      requestFieldCacheKey,
-      requestFieldPath,
-      responseDataPath
-    } = keysAndPaths;
-    const fieldData = get(requestFieldPathData, responseDataPath);
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    if (!isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
-      return;
-    }
-    if (isObjectLike(fieldData)) {
-      const promises = [];
-      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(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 = isEqual(entityData, requestFieldPathData) ? entityData : combineDataSets(entityData, requestFieldPathData, this._typeIDKey);
-    return {
-      cacheability,
-      data,
-      entityData,
-      requestFieldPathData
-    };
-  }
-  async _retrieveCachedRequestFieldPathData(hash, requestFieldCacheKey, options, context) {
-    return (await this._checkCacheEntry(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 = getOperationDefinitions(ast, context.operation)[0];
-    if (!queryNode) {
-      return cachedResponseData;
-    }
-    const fieldsAndTypeNames = 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}`, cloneDeep(value), cachemapOptions);
-    } catch {}
-  }
-  async _setEntityAndRequestFieldPathCacheEntries(requestData, responseData, options, context) {
-    const operationNode = getOperationDefinitions(requestData.ast, context.operation)[0];
-    if (!operationNode) {
-      return;
-    }
-    const fieldsAndTypeNames = 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 = get(entityData, responseDataPath);
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    const cacheability = cacheMetadata.get(requestFieldPath);
-    if (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) {
-      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 = get(data, responseDataPath);
-    const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
-    const entityDataKey = `${fieldTypeName}::${String(fieldData[this._typeIDKey])}`;
-    const result = await this._checkCacheEntry(DATA_ENTITIES, entityDataKey, options, context);
-    if (result) {
-      fieldData = mergeDataSets(result.entry, fieldData, this._typeIDKey);
-    }
-    await this._setCacheEntry(DATA_ENTITIES, entityDataKey, fieldData, {
-      cacheHeaders: {
-        cacheControl: cacheability.printCacheControl()
-      },
-      tag: options.tag
-    }, options, context);
-    set(data, responseDataPath, {
-      __cacheKey: `${DATA_ENTITIES}::${entityDataKey}`
-    });
-  }
-  _setFieldCacheability(field, ancestorKeysAndPaths, {
-    cacheMetadata,
-    data
-  }, options, context) {
-    const {
-      requestFieldPath: ancestorRequestFieldPath
-    } = ancestorKeysAndPaths;
-    const keysAndPaths = buildFieldKeysAndPaths(field, ancestorKeysAndPaths, context);
-    const {
-      requestFieldPath,
-      responseDataPath
-    } = keysAndPaths;
-    if (!isObjectLike(data)) {
-      return;
-    }
-    const fieldData = get(data, responseDataPath);
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    if (!isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
-      return;
-    }
-    this._setFieldTypeCacheDirective(cacheMetadata, {
-      ancestorRequestFieldPath,
-      requestFieldPath
-    }, context);
-    if (isObjectLike(fieldData)) {
-      iterateChildFields(field, fieldData, context.fragmentDefinitions, (childField, _typeName, _fragmentKind, _fragmentName, childIndex) => {
-        this._setFieldCacheability(childField, {
-          index: childIndex,
-          requestFieldPath,
-          responseDataPath
-        }, {
-          cacheMetadata,
-          data
-        }, options, context);
-      });
-    }
-  }
-  _setFieldTypeCacheDirective(cacheMetadata, {
-    ancestorRequestFieldPath,
-    requestFieldPath
-  }, {
-    fieldTypeMap,
-    operation
-  }) {
-    if (cacheMetadata.has(requestFieldPath)) {
-      return;
-    }
-    const fieldTypeInfo = fieldTypeMap.get(requestFieldPath);
-    if (fieldTypeInfo && this._typeCacheDirectives[fieldTypeInfo.typeName]) {
-      const cacheability = new Cacheability({
-        cacheControl: this._typeCacheDirectives[fieldTypeInfo.typeName]
-      });
-      CacheManager._setCacheMetadata(cacheMetadata, cacheability, 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 = dehydrateCacheMetadata(cacheMetadata);
-    const cacheControl = CacheManager._getOperationCacheControl(cacheMetadata, context.operation);
-    await this._setCacheEntry(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 = get(data, responseDataPath);
-    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
-    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
-    if (context.operation === OperationTypeNode.QUERY && (isEntity || hasArgsOrDirectives)) {
-      if (isPlainObject(fieldData) && field.selectionSet?.selections) {
-        fieldData = filterOutPropsWithArgsOrDirectives(fieldData, field.selectionSet.selections, keysAndPaths, context);
-      }
-      const result = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, {
-        ...context,
-        requestFieldCacheKey
-      });
-      if (result && isObjectLike(result.entry) && isObjectLike(fieldData)) {
-        fieldData = mergeDataSets(result.entry, fieldData, this._typeIDKey);
-      }
-      await this._setCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, fieldData, {
-        cacheHeaders: {
-          cacheControl: cacheability.printCacheControl()
-        },
-        tag: options.tag
-      }, options, {
-        ...context,
-        requestFieldCacheKey
-      });
-      if (hasChildFields(field, {
-        fragmentDefinitions: context.fragmentDefinitions
-      })) {
-        if (isEntity) {
-          set(data, responseDataPath, {
-            __cacheKey: `${REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}`
-          });
-        } else {
-          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));
-
-export { CacheManager };
+import e from"@babel/runtime/helpers/defineProperty";import t from"@babel/runtime/helpers/applyDecoratedDescriptor";import"core-js/modules/es.array.push.js";import{CACHE_ENTRY_ADDED as a,CACHE_ENTRY_QUERIED as s,PARTIAL_QUERY_COMPILED as i,TYPE_NAME_KEY as n,DEFAULT_TYPE_ID_KEY as r,QUERY_RESPONSES as c,DATA_ENTITIES as h,REQUEST_FIELD_PATHS as o}from"@graphql-box/core";import{isPlainObject as d,isArray as l,mergeObjects as y,isObjectLike as p,resolveFragments as u,getName as f,buildFieldKeysAndPaths as _,deleteFragmentSpreads as m,getChildFields as g,deleteChildFields as C,getInlineFragments as D,deleteInlineFragments as F,hasChildFields as P,deleteFragmentDefinitions as q,getOperationDefinitions as E,ArgsError as R,GroupedError as w,getFragmentDefinitions as N,hashRequest as M,rehydrateCacheMetadata as b,iterateChildFields as v,dehydrateCacheMetadata as K}from"@graphql-box/helpers";import{Cacheability as I}from"cacheability";import{Kind as k,print as T,OperationTypeNode as A}from"graphql";import{isNumber as x,isString as O,isEmpty as Q,keys as $,merge as j,set as z,cloneDeep as S,get as H,isUndefined as U,assign as G,isEqual as L,unset as V}from"lodash-es";const Y="noCache",B=(e,t)=>l(e)?e.reduce(((e,a)=>!!e&&B(a,t)),!0):!!d(e)&&J(e,t),J=(e,t)=>{const a=d(e)?Object.keys(e):[...e.keys()];return!(1!==a.length||!d(e)||!e[t])||a.reduce(((a,s)=>!!a&&(x(s)&&l(e)||O(s)&&d(e)?B(e[s],t):a)),!0)},W=(e,t,a)=>y(e,t,((e,t)=>d(t)&&t[a]?t[a]:void 0)),X=(e,t,a)=>!e&&t?t:p(e)&&p(t)?W(e,t,a):e,Z=(e,t)=>{if(!e||0===e.length)return{hasData:!1,typeUnused:!!t};const[a]=e;if(a){const{hasData:e,typeName:s}=a;return{hasData:e,typeUnused:s?s!==t:void 0}}return{hasData:e.some((({hasData:e,typeName:a})=>a===t&&e)),typeUnused:!e.every((({typeName:e})=>e===t))}},ee=(e,t,a,s,i)=>{const{fragmentDefinitions:r,typeIDKey:c}=i,h=g(e,{fragmentDefinitions:r});if(!h)return!1;const o={};for(let d=h.length-1;d>=0;d-=1){const l=h[d];if(!l)continue;const{fieldNode:y,fragmentKind:p,fragmentName:u,typeName:m}=l;p===k.FRAGMENT_SPREAD&&u&&!o[u]&&(o[u]={hasData:0,total:r?.[u]?g(r[u],{fragmentDefinitions:r})?.length??0:0});const D=f(y);if(D===c||D===n)continue;const{requestFieldPath:F}=_(y,{requestFieldPath:s},i),{hasData:q,typeUnused:E}=Z(t.get(F),m);if(q||E)if(p===k.FRAGMENT_SPREAD&&u){const e=o[u];e&&(e.hasData+=1)}else P(y,{fragmentDefinitions:r})?ee(y,t,a,F,i)&&C(e,y):C(e,y)}return((e,t,a,s)=>{if(!Q(t))for(const i of Object.keys(t)){const n=a[i];if(!n)continue;n.paths.push(s);const{hasData:r,total:c}=t[i];r===c&&(m(e,i),n.deleted+=1)}})(e,o,a,s),((e,{fragmentDefinitions:t,typeIDKey:a})=>{const s=D(e);let i=!1;for(const n of s){const s=g(n,{fragmentDefinitions:t});if(!s||0===s.length){F(e,n),i=!0;continue}const[r]=s;if(r){const{fieldNode:t}=r;f(t)===a&&(F(e,n),i=!0)}}})(e,i),((e,{fragmentDefinitions:t,typeIDKey:a})=>{const s=g(e,{fragmentDefinitions:t});if(!s||s.length>3)return!1;const i=s.map((({fieldNode:e})=>f(e)));if(2===i.length&&i.every((e=>e===a||e===n)))return C(e,s.map((({fieldNode:e})=>e))),!0;if(1===i.length&&i[0]===a||i[0]===n){const[t]=s;if(t){const{fieldNode:a}=t;return C(e,a),!0}}})(e,i),!P(e,{fragmentDefinitions:r})},te=(e,{fieldPathChecklist:t},a)=>{const{ast:s}=e,i=E(s,a.operation)[0];if(!i)return s;const{fragmentDefinitions:n,operation:r}=a,c=g(i,{fragmentDefinitions:n});if(!c)return s;const h=(({request:e},{fragmentDefinitions:t})=>$(t??{}).reduce(((t,a)=>(t[a]={deleted:0,paths:[],total:(e.match(new RegExp(`\\.\\.\\.${a}`,"g"))??[]).length},t)),{}))(e,a);for(let e=c.length-1;e>=0;e-=1){const{fieldNode:s}=c[e],{requestFieldPath:n}=_(s,{requestFieldPath:r},a);ee(s,t,h,n,a)&&C(i,s)}return a.queryFiltered=!0,((e,t,a,s)=>{const i=$(a).reduce(((e,t)=>{const s=a[t];if(!s)return e;const{deleted:i,paths:n,total:r}=s;return 0===i&&1===r?[...e,{name:t,path:n[0]}]:e}),[]),{fragmentDefinitions:n={}}=s;for(const{name:e,path:r}of i){const i=n[e];i&&ee(i,t,a,r,s)}const r=$(a).reduce(((e,t)=>{const s=a[t];if(!s)return e;const{deleted:i,total:n}=s;return i>0&&i===n?[...e,t]:e}),[]);return 0===r.length?e:q(e,{include:r})})(s,t,h,a)},ae=(e,t)=>l(e)&&x(t)||d(e)&&O(t)?e[t]:void 0,se=e=>!!p(e)&&(n in e&&O(e[n]));var ie,ne,re,ce;let he=(ie=(e,t,a)=>{const i=a.value;i&&(a.value=async function(...e){return new Promise((t=>{(async()=>{const{debugManager:a,requestFieldCacheKey:n,...r}=e[3];if(!a)return void t(await i.apply(this,e));const c=a.now(),h=await i.apply(this,e),o=a.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}:{}};a.log(s,l)})()}))})},ne=(e,t,s)=>{const i=s.value;i&&(s.value=async function(...e){return new Promise((t=>{(async()=>{const{debugManager:s,requestFieldCacheKey:n,...r}=e[5];if(!s)return await i.apply(this,e),void t();const c=s.now();await i.apply(this,e);const h=s.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}:{}};s.log(a,d)})()}))})},re=(e,t,a)=>{const s=a.value;s&&(a.value=function(...e){const{debugManager:t,...a}=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(i,{context:a,options:e[2],requestHash:e[0],result:e[1],stats:{duration:c,endTime:r,startTime:n}})})},ce=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=ae(e,t);return p(a)?S(a):a}static _getOperationCacheControl(e,t){const a="no-cache";if(!e)return a;const s=e.get(t);return s?s.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!H(e,["metadata","cacheControl",Y],!1)&&e.checkTTL()}static _mergeResponseCacheMetadata(e,t){return t?new Map([...t.cacheMetadata,...e]):e}static _setCachedData(e,{data:t},a){const s=t=>{(l(e)&&x(a)||d(e))&&(e[a]=t)};p(t)||U(t)?l(t)?s([]):d(t)&&s({}):s(t)}static _setCachedResponseData(e,{cacheMetadata:a,data:s,fieldPathChecklist:i},{propNameOrIndex:n,requestFieldPath:r},c,h,{operation:o}){t._setCacheMetadata(a,e.cacheability,r,o),t._setFieldPathChecklist(i,e,r,c),t._setCachedData(s,e,n)}static _setCacheMetadata(e,t,a,s){if(!t)return;e.set(a,t);const i=e.get(s);(!i||i.metadata.ttl>t.metadata.ttl)&&e.set(s,t)}static _setFieldPathChecklist(e,{data:t},a,{dataTypename:s,fieldTypename:i,fragmentKind:n,fragmentName:r}){if(U(i)||n===k.FRAGMENT_SPREAD){if(e.has(a))return;return void e.set(a,[{fragmentKind:n,fragmentName:r,hasData:!U(t)}])}if(s!==i)return;const c=e.get(a)??[];c.some((({typeName:e})=>e===s))||e.set(a,[...c,{fragmentKind:n,fragmentName:r,hasData:!U(t),typeName:s}])}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 a=[];if("cache"in t||a.push(new R("@graphql-box/cache-manager expected cache to be in options.")),t.typeCacheDirectives&&!d(t.typeCacheDirectives)){const e="@graphql-box/cache-manager expected options.typeCacheDirectives to be a plain object.";a.push(new R(e))}if(a.length>0)throw new w("@graphql-box/cache-manager argument validation errors.",a);this._cache=t.cache,this._cascadeCacheControl=t.cascadeCacheControl??!1,this._fallbackOperationCacheability=t.fallbackOperationCacheability??Y,this._typeCacheDirectives=t.typeCacheDirectives??{},this._typeIDKey=t.typeIDKey??r}async analyzeQuery(e,t,a){const{ast:s,hash:i}=e,n={...a,fragmentDefinitions:N(s),typeIDKey:this._typeIDKey},r=await this._retrieveCachedResponseData(e,t,n),{cacheMetadata:c,data:h,fieldCount:o}=r;if(o.missing===o.total||((e,t)=>J(e,t))(h,this._typeIDKey))return{updated:e};if(!o.missing){const e=this._setQueryResponseCacheEntry(i,{cacheMetadata:c,data:h},t,n);return t.awaitDataCaching&&await e,{response:{cacheMetadata:c,data:h}}}const d=te(e,r,n),l=T(d),{fragmentDefinitions:y,typeIDKey:p,...u}=n;return G(a,{...u,filteredRequest:l}),this._setPartialQueryResponse(i,{cacheMetadata:c,data:h},t,a),{updated:{ast:d,hash:M(l),request:l}}}get cache(){return this._cache}async cacheQuery(e,t,a,s,i){const n={...i,fragmentDefinitions:N((t??e).ast),typeIDKey:this._typeIDKey};return this._cacheResponse(e,t,a,s,n)}async cacheResponse(e,t,a,s){const i={...s,fragmentDefinitions:N(e.ast),typeIDKey:this._typeIDKey};return this._cacheResponse(e,void 0,t,a,i)}async checkCacheEntry(e,t,a,s){return this._checkCacheEntry(e,t,a,s)}async checkQueryResponseCacheEntry(e,t,a){const s=await this._checkCacheEntry(c,e,t,a);if(!s)return!1;const{cacheMetadata:i,data:n}=s.entry;return{cacheMetadata:b(i),data:n}}deletePartialQueryResponse(e){this._partialQueryResponses.delete(e)}async setQueryResponseCacheEntry(e,t,a,s){return this._setQueryResponseCacheEntry(e.hash,t,a,s)}async _analyzeFieldNode(e,t,a,s,i){await(P(e,{fragmentDefinitions:i.fragmentDefinitions})?this._analyzeParentFieldNode(e,t,a,s,i):this._analyzeLeafFieldNode(e,t,a,s,i))}async _analyzeLeafFieldNode(e,a,s,i,n){const r=_(e,a,n),{hashedRequestFieldCacheKey:c,propNameOrIndex:h,requestFieldCacheKey:o,requestFieldPath:d}=r,l=n.fieldTypeMap.get(d),{entityData:y,fragmentKind:p,fragmentName:u,requestFieldPathData:f,typeName:m}=a,g={dataTypename:se(y)?y.__typename:se(f)?f.__typename:void 0,fieldTypename:m,fragmentKind:p,fragmentName:u};if(t._isNodeRequestFieldPath(l)){const{cacheability:e,entry:a}=await this._retrieveCachedRequestFieldPathData(c,o,i,n);t._setCachedResponseData({cacheability:e,data:a},s,r,g,i,n)}else{const e=t._getFieldDataFromAncestor(y,h)??t._getFieldDataFromAncestor(f,h);t._setFieldPathChecklist(s.fieldPathChecklist,{data:e},d,g),t._setCachedData(s.data,{data:e},h)}}async _analyzeParentFieldNode(e,a,s,i,r){const c=_(e,a,r),{propNameOrIndex:h,requestFieldCacheKey:o,requestFieldPath:d}=c,l=r.fieldTypeMap.get(d),{cacheability:y,data:u,entityData:f,requestFieldPathData:m}=await this._retrieveCachedParentNodeData(a,c,l,i,r),{fragmentKind:g,fragmentName:C,typeName:D}=a;if(t._setCachedResponseData({cacheability:y,data:u},s,c,{dataTypename:H(u,n),fieldTypename:D,fragmentKind:g,fragmentName:C},i,r),!p(u))return;const F=[];v(e,u,r.fragmentDefinitions,((e,t,a,n,c)=>{F.push(this._analyzeFieldNode(e,{cacheability:y,entityData:f,fragmentKind:a,fragmentName:n,index:c,requestFieldCacheKey:o,requestFieldPath:d,requestFieldPathData:m,typeName:t},{...s,data:ae(s.data,h)},i,r))})),await Promise.all(F)}_buildCacheMetadata({ast:e},{data:t,...a},s,i){const n=this._createCacheMetadata({data:t,...a},i),r=E(e,i.operation)[0];if(!r)return n;const c=g(r);if(!c)return n;for(const{fieldNode:e}of c)this._setFieldCacheability(e,{requestFieldPath:i.operation},{cacheMetadata:n,data:t},s,i);return n}async _cacheResponse(e,a,s,i,n){const r=((e,t)=>{if(!t.normalizePatchResponseData)return e;const{data:a,paths:s,...i}=e;return s?.length&&O(s[0])?{...i,data:z({},s[0],a),paths:s}:e})(s,n);let c=r;((e,t)=>t.hasDeferOrStream&&e.hasNext)(s,n)&&(this._setResponseChunksAwaitingCaching(r,n),c=void 0),((e,t)=>t.hasDeferOrStream&&!e.hasNext&&e.paths)(s,n)&&(c=this._retrieveResponseDataForCaching(r,n));const h=[];if(c){const{data:s}=c,o=this._buildCacheMetadata(e,c,i,n);let d,l;if(h.push(this._setEntityAndRequestFieldPathCacheEntries(e,{cacheMetadata:o,entityData:S(s),requestFieldPathData:S(s)},i,n)),n.operation===A.QUERY){let r;n.queryFiltered&&a&&(h.push(this._setQueryResponseCacheEntry(a.hash,{cacheMetadata:o,data:s},i,n)),r=this._getPartialQueryResponse(e.hash)),d=t._mergeResponseCacheMetadata(o,r),l=this._mergeResponseData(s,r),h.push(this._setQueryResponseCacheEntry(e.hash,{cacheMetadata:d,data:l},i,n))}if(i.awaitDataCaching&&await Promise.all(h),((e,t)=>!t.hasDeferOrStream&&!e.hasNext&&!e.paths)(r,n)&&d&&l)return{cacheMetadata:d,data:l}}const{data:o,hasNext:d,paths:l}=r;return{cacheMetadata:this._buildCacheMetadata(e,r,i,n),data:o,hasNext:d,paths:l}}async _checkCacheEntry(e,a,s,i){try{const n=await this._hasCacheEntry(e,a);if(!n||!t._isValid(n))return!1;const r=await this._getCacheEntry(e,a,s,i);return!U(r)&&{cacheability:n,entry:r}}catch{return!1}}_createCacheMetadata({_cacheMetadata:e,headers:t},{operation:a}){const s=new Map,i=(({_cacheMetadata:e,fallback:t,headers:a})=>{if(e&&!Q(e)){const[t,...a]=Object.values(e);return new I({metadata:a.reduce(((e,t)=>e?t.ttl<e.ttl?t:e:t),t)})}return a?.has("cache-control")?new I({headers:a}):new I({cacheControl:t})})({_cacheMetadata:e,fallback:this._fallbackOperationCacheability,headers:t});return s.set(a,i),e&&b(e,s),s}async _getCacheEntry(e,t,a,s){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!(!d(e)||!(this._typeIDKey in e))&&(!!t||0!==a.length&&a.some((t=>t.typeName===e.__typename)))}_mergeResponseData(e,t){return t?W(t.data,e,this._typeIDKey):e}async _parseEntityAndRequestFieldPathCacheEntryData(e,t,{cacheMetadata:a,entityData:s,requestFieldPathData:i},n,r){const c=_(e,t,r),{requestFieldCacheKey:h,requestFieldPath:o,responseDataPath:d}=c,l=H(i,d),y=r.fieldTypeMap.get(o);if(p(l)||y?.hasDirectives){if(p(l)){const t=[];v(e,l,r.fragmentDefinitions,((e,c,l,y,p)=>{t.push(this._parseEntityAndRequestFieldPathCacheEntryData(e,{index:p,requestFieldCacheKey:h,requestFieldPath:o,responseDataPath:d},{cacheMetadata:a,entityData:s,requestFieldPathData:i},n,r))})),await Promise.all(t)}await this._setEntityAndRequestFieldPathCacheEntry(e,c,{cacheMetadata:a,entityData:s,requestFieldPathData:i},n,r)}}async _retrieveCachedEntityData(e,{possibleTypes:t,typeName:a},s,i){const n=[...t.map((e=>e.typeName)),a],r=(await Promise.all(n.map((t=>this._checkCacheEntry(h,`${t}::${e}`,s,i))))).filter((e=>!!e));let c;return 1===r.length?c=r[0]:r.length>1&&(r.sort((({cacheability:e},{cacheability:t})=>e.metadata.ttl-t.metadata.ttl)),c={cacheability:r[0].cacheability,entry:r.reduce(((e,{entry:t})=>W(e,t,this._typeIDKey)),{})}),c??{}}async _retrieveCachedParentNodeData({entityData:e,requestFieldPathData:a},{hashedRequestFieldCacheKey:s,propNameOrIndex:i,requestFieldCacheKey:n},r,c,h){let o,l=t._getFieldDataFromAncestor(e,i),y=t._getFieldDataFromAncestor(a,i);if(t._isNodeRequestFieldPath(r)){const{cacheability:e,entry:t}=await this._retrieveCachedRequestFieldPathData(s,n,c,h);y=X(y,t,this._typeIDKey),e&&(o=e)}const p=((e,{typeIDValue:t},a)=>t||(d(e)?e[a]:void 0))(y,r,this._typeIDKey);if(t._isNodeEntity(r)&&p){const{cacheability:e,entry:t}=await this._retrieveCachedEntityData(p,r,c,h);l=X(l,t,this._typeIDKey),e&&(!o||e.metadata.ttl>o.metadata.ttl)&&(o=e)}return{cacheability:o,data:L(l,y)?l:X(l,y,this._typeIDKey),entityData:l,requestFieldPathData:y}}async _retrieveCachedRequestFieldPathData(e,t,a,s){return await this._checkCacheEntry(o,e,a,{...s,requestFieldCacheKey:t})||{}}async _retrieveCachedResponseData({ast:e},a,s){const i={cacheMetadata:new Map,data:{},fieldCount:{missing:0,total:0},fieldPathChecklist:new Map},n=E(e,s.operation)[0];if(!n)return i;const r=g(n);return r?(await Promise.all(r.map((({fieldNode:e})=>this._analyzeFieldNode(e,{requestFieldPath:s.operation},i,a,s)))),i.fieldCount=t._countFieldPathChecklist(i.fieldPathChecklist),i):i}_retrieveResponseDataForCaching(e,t){const a=this._responseChunksAwaitingCaching.get(t.requestID);return this._responseChunksAwaitingCaching.delete(t.requestID),(s=[...a,e]).reduce(((e,t,a)=>{const{_cacheMetadata:i,data:n,hasNext:r,headers:c,paths:h}=t;return i&&(e._cacheMetadata=e._cacheMetadata?{...e._cacheMetadata,...i}:i),e.data=j(e.data,n),0===a&&(e.headers=c),a===s.length-1&&(e.hasNext=r),h&&(e.paths||(e.paths=[]),e.paths.push(...h)),e}),{data:{}});var s}async _setCacheEntry(e,t,a,s,i,n){try{await this._cache.set(`${e}::${t}`,S(a),s)}catch{}}async _setEntityAndRequestFieldPathCacheEntries(e,t,a,s){const i=E(e.ast,s.operation)[0];if(!i)return;const n=g(i);n&&await Promise.all(n.map((({fieldNode:e})=>this._parseEntityAndRequestFieldPathCacheEntryData(e,{requestFieldPath:s.operation},t,a,s))))}async _setEntityAndRequestFieldPathCacheEntry(e,t,{cacheMetadata:a,entityData:s,requestFieldPathData:i},n,r){const{requestFieldPath:c,responseDataPath:h}=t,o=H(s,h),d=r.fieldTypeMap.get(c),l=a.get(c);if(U(o)||!d||!l)return;const y=[];y.push(this._setRequestFieldPathCacheEntry(e,t,{cacheability:l,data:i,fieldTypeInfo:d},n,r));const p=this._isFieldEntity(o,d);!p&&d.hasArguments&&V(s,h),p&&y.push(this._setEntityCacheEntry(t,{cacheability:l,data:s,fieldTypeInfo:d},n,r)),await Promise.all(y)}async _setEntityCacheEntry({responseDataPath:e},{cacheability:t,data:a,fieldTypeInfo:s},i,n){let r=H(a,e);const c=`${s.isEntity?s.typeName:r.__typename}::${String(r[this._typeIDKey])}`,o=await this._checkCacheEntry(h,c,i,n);o&&(r=W(o.entry,r,this._typeIDKey)),await this._setCacheEntry(h,c,r,{cacheHeaders:{cacheControl:t.printCacheControl()},tag:i.tag},i,n),z(a,e,{__cacheKey:`${h}::${c}`})}_setFieldCacheability(e,t,{cacheMetadata:a,data:s},i,n){const{requestFieldPath:r}=t,c=_(e,t,n),{requestFieldPath:h,responseDataPath:o}=c;if(!p(s))return;const d=H(s,o),l=n.fieldTypeMap.get(h);(p(d)||l?.hasDirectives)&&(this._setFieldTypeCacheDirective(a,{ancestorRequestFieldPath:r,requestFieldPath:h},n),p(d)&&v(e,d,n.fragmentDefinitions,((e,t,r,c,d)=>{this._setFieldCacheability(e,{index:d,requestFieldPath:h,responseDataPath:o},{cacheMetadata:a,data:s},i,n)})))}_setFieldTypeCacheDirective(e,{ancestorRequestFieldPath:a,requestFieldPath:s},{fieldTypeMap:i,operation:n}){if(e.has(s))return;const r=i.get(s);if(r&&this._typeCacheDirectives[r.typeName]){const a=new I({cacheControl:this._typeCacheDirectives[r.typeName]});t._setCacheMetadata(e,a,s,n)}else this._cascadeCacheControl&&a&&t._setCacheMetadata(e,e.get(a),s,n)}_setPartialQueryResponse(e,t,a,s){this._partialQueryResponses.set(e,t)}async _setQueryResponseCacheEntry(e,{cacheMetadata:a,data:s},i,n){const r=K(a),h=t._getOperationCacheControl(a,n.operation);await this._setCacheEntry(c,e,{cacheMetadata:r,data:s},{cacheHeaders:{cacheControl:h},tag:i.tag},i,n)}async _setRequestFieldPathCacheEntry(e,t,{cacheability:a,data:s,fieldTypeInfo:i},n,r){const{hashedRequestFieldCacheKey:c,requestFieldCacheKey:h,responseDataPath:l}=t;let y=H(s,l);const m=this._isFieldEntity(y,i),g=i.hasArguments||i.hasDirectives;if(r.operation===A.QUERY&&(m||g)){d(y)&&e.selectionSet?.selections&&(y=((e,t,a,s)=>{const i=u(t,s.fragmentDefinitions);return $(e).reduce(((t,n)=>{const r=i.find((({fieldNode:e})=>f(e)===n));if(r){const{requestFieldPath:i}=_(r.fieldNode,a,s),c=s.fieldTypeMap.get(i);c?.hasArguments||c?.hasDirectives||(t[n]=e[n])}return t}),{})})(y,e.selectionSet.selections,t,r));const i=await this._checkCacheEntry(o,c,n,{...r,requestFieldCacheKey:h});i&&p(i.entry)&&p(y)&&(y=W(i.entry,y,this._typeIDKey)),await this._setCacheEntry(o,c,y,{cacheHeaders:{cacheControl:a.printCacheControl()},tag:n.tag},n,{...r,requestFieldCacheKey:h}),P(e,{fragmentDefinitions:r.fragmentDefinitions})&&(m?z(s,l,{__cacheKey:`${o}::${c}`}):V(s,l))}}_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(ce.prototype,"_getCacheEntry",[ie],Object.getOwnPropertyDescriptor(ce.prototype,"_getCacheEntry"),ce.prototype),t(ce.prototype,"_setCacheEntry",[ne],Object.getOwnPropertyDescriptor(ce.prototype,"_setCacheEntry"),ce.prototype),t(ce.prototype,"_setPartialQueryResponse",[re],Object.getOwnPropertyDescriptor(ce.prototype,"_setPartialQueryResponse"),ce.prototype),ce);export{he as CacheManager};
 //# sourceMappingURL=index.mjs.map