@graphql-box/cache-manager 4.1.4 → 5.0.0

package/{lib/module/main/index.js → dist/esm/index.mjs}

@@ -1,106 +1,678 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _applyDecoratedDescriptor from "@babel/runtime/helpers/applyDecoratedDescriptor";
-import _unset from "lodash/unset";
-import _set from "lodash/set";
-import _isUndefined from "lodash/isUndefined";
-import _isPlainObject from "lodash/isPlainObject";
-import _isObjectLike from "lodash/isObjectLike";
-import _isArray from "lodash/isArray";
-import _get from "lodash/get";
-import _cloneDeep from "lodash/cloneDeep";
-import _assign from "lodash/assign";
+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);
+        })();
+      });
+    };
+  };
+};
 
-var _dec, _dec2, _dec3, _class;
+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;
+};
 
-import "core-js/modules/es.promise.js";
-import { DATA_ENTITIES, DEFAULT_TYPE_ID_KEY, QUERY, QUERY_RESPONSES, REQUEST_FIELD_PATHS, TYPE_NAME_KEY } from "@graphql-box/core";
-import { FRAGMENT_SPREAD, buildFieldKeysAndPaths, dehydrateCacheMetadata, getChildFields, getFragmentDefinitions, getOperationDefinitions, hasChildFields, hashRequest, iterateChildFields, mergeObjects, rehydrateCacheMetadata } from "@graphql-box/helpers";
-import Cacheability from "cacheability";
-import { print } from "graphql";
-import { CACHE_CONTROL, HEADER_NO_CACHE, METADATA, NO_CACHE } from "../consts";
-import { logCacheEntry, logCacheQuery, logPartialCompiled } from "../debug";
-import areOnlyPopulatedFieldsTypeIdKeys from "../helpers/areOnlyPopulatedFieldsTypeIdKeys";
-import deriveOpCacheability from "../helpers/deriveOpCacheability";
-import filterOutPropsWithArgsOrDirectives from "../helpers/filterOutPropsWithArgsOrDirectives";
-import filterQuery from "../helpers/filterQuery";
-import isLastResponseChunk from "../helpers/isLastResponseChunk";
-import isNotLastResponseChunk from "../helpers/isNotLastResponseChunk";
-import isNotResponseChunk from "../helpers/isNotResponseChunk";
-import mergeResponseDataSets from "../helpers/mergeResponseDataSets";
-import normalizePatchResponseData from "../helpers/normalizePatchResponseData";
-import { getValidTypeIDValue } from "../helpers/validTypeIDValue";
+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
     };
-    fieldPathChecklist.forEach(checklistValues => {
+    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) {
-    return _isObjectLike(ancestorFieldData) ? _cloneDeep(ancestorFieldData[propNameOrIndex]) : undefined;
+    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);
-
+    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(requestData, {
+  static _setCachedData(responseData, {
     data
   }, propNameOrIndex) {
-    if (!_isObjectLike(data) && !_isUndefined(data)) {
-      requestData[propNameOrIndex] = data;
-    } else if (_isObjectLike(data)) {
-      const objectLikeData = data;
-      requestData[propNameOrIndex] = _isArray(objectLikeData) ? [] : {};
+    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,
@@ -112,121 +684,87 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
     operation
   }) {
     CacheManager._setCacheMetadata(cacheMetadata, cachedFieldData.cacheability, requestFieldPath, operation);
-
     CacheManager._setFieldPathChecklist(fieldPathChecklist, cachedFieldData, requestFieldPath, typeNamesAndKind);
-
     CacheManager._setCachedData(data, cachedFieldData, propNameOrIndex);
   }
-
   static _setCacheMetadata(cacheMetadata, cacheability, requestFieldPath, operation) {
     if (!cacheability) {
       return;
     }
-
     cacheMetadata.set(requestFieldPath, cacheability);
     const operationCacheability = cacheMetadata.get(operation);
-
     if (!operationCacheability || operationCacheability.metadata.ttl > cacheability.metadata.ttl) {
       cacheMetadata.set(operation, cacheability);
     }
   }
-
   static _setFieldPathChecklist(fieldPathChecklist, {
     data
   }, requestFieldPath, {
-    dataTypeName,
-    fieldTypeName,
+    dataTypename: dataTypeName,
+    fieldTypename: fieldTypeName,
     fragmentKind,
     fragmentName
   }) {
-    if (_isUndefined(fieldTypeName) || fragmentKind === FRAGMENT_SPREAD) {
+    if (isUndefined(fieldTypeName) || fragmentKind === Kind.FRAGMENT_SPREAD) {
       if (fieldPathChecklist.has(requestFieldPath)) {
         return;
       }
-
       fieldPathChecklist.set(requestFieldPath, [{
         fragmentKind,
         fragmentName,
-        hasData: !_isUndefined(data)
+        hasData: !isUndefined(data)
       }]);
       return;
     }
-
     if (dataTypeName !== fieldTypeName) {
       return;
     }
-
     const entry = fieldPathChecklist.get(requestFieldPath);
-    const checklistValues = entry ? entry : [];
-
+    const checklistValues = entry ?? [];
     if (checklistValues.some(({
       typeName
     }) => typeName === dataTypeName)) {
       return;
     }
-
     fieldPathChecklist.set(requestFieldPath, [...checklistValues, {
       fragmentKind,
       fragmentName,
-      hasData: !_isUndefined(data),
+      hasData: !isUndefined(data),
       typeName: dataTypeName
     }]);
   }
-
   constructor(options) {
-    var _options$typeIDKey;
-
     _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 (!options.cache) {
-      errors.push(new TypeError("@graphql-box/cache-manager expected options.cache."));
+    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 TypeError(message));
+    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) {
-      throw errors;
+    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 = options.typeIDKey) !== null && _options$typeIDKey !== void 0 ? _options$typeIDKey : DEFAULT_TYPE_ID_KEY;
-  }
-
-  get cache() {
-    return this._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;
-
-    if (!ast) {
-      return Promise.reject(new TypeError("@graphql-box/cache-manager expected an AST."));
-    }
-
-    const cacheManagerContext = { ...context,
+    const cacheManagerContext = {
+      ...context,
       fragmentDefinitions: getFragmentDefinitions(ast),
       typeIDKey: this._typeIDKey
     };
@@ -236,23 +774,19 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       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,
@@ -260,7 +794,6 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
         }
       };
     }
-
     const filteredAST = filterQuery(requestData, cachedResponseData, cacheManagerContext);
     const filteredRequest = print(filteredAST);
     const {
@@ -268,16 +801,14 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       typeIDKey,
       ...rest
     } = cacheManagerContext;
-
-    _assign(context, { ...rest,
+    assign(context, {
+      ...rest,
       filteredRequest
     });
-
     this._setPartialQueryResponse(hash, {
       cacheMetadata,
       data
     }, options, context);
-
     return {
       updated: {
         ast: filteredAST,
@@ -286,34 +817,33 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       }
     };
   }
-
+  get cache() {
+    return this._cache;
+  }
   async cacheQuery(requestData, updatedRequestData, rawResponseData, options, context) {
-    const cacheManagerContext = { ...context,
-      fragmentDefinitions: getFragmentDefinitions((updatedRequestData !== null && updatedRequestData !== void 0 ? updatedRequestData : requestData).ast),
+    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,
+    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
@@ -323,25 +853,17 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       data
     };
   }
-
   deletePartialQueryResponse(hash) {
     this._partialQueryResponses.delete(hash);
   }
-
   async setQueryResponseCacheEntry(requestData, responseData, options, context) {
     return this._setQueryResponseCacheEntry(requestData.hash, responseData, options, context);
   }
-
   async _analyzeFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
-    if (hasChildFields(fieldNode, {
+    await (hasChildFields(fieldNode, {
       fragmentDefinitions: context.fragmentDefinitions
-    })) {
-      await this._analyzeParentFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
-    } else {
-      await this._analyzeLeafFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
-    }
+    }) ? 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 {
@@ -358,36 +880,32 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       requestFieldPathData,
       typeName
     } = cachedAncestorFieldData;
-    const typeNamesAndKind = {
-      dataTypeName: (entityData === null || entityData === void 0 ? void 0 : entityData.__typename) || (requestFieldPathData === null || requestFieldPathData === void 0 ? void 0 : requestFieldPathData.__typename),
-      fieldTypeName: typeName,
+    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);
+      }, cachedResponseData, keysAndPaths, typenamesAndKind, options, context);
     } else {
-      const cachedFieldData = CacheManager._getFieldDataFromAncestor(entityData, propNameOrIndex) || CacheManager._getFieldDataFromAncestor(requestFieldPathData, propNameOrIndex);
-
+      const cachedFieldData = CacheManager._getFieldDataFromAncestor(entityData, propNameOrIndex) ?? CacheManager._getFieldDataFromAncestor(requestFieldPathData, propNameOrIndex);
       CacheManager._setFieldPathChecklist(cachedResponseData.fieldPathChecklist, {
         data: cachedFieldData
-      }, requestFieldPath, typeNamesAndKind);
-
+      }, requestFieldPath, typenamesAndKind);
       CacheManager._setCachedData(cachedResponseData.data, {
         data: cachedFieldData
       }, propNameOrIndex);
     }
   }
-
   async _analyzeParentFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
     const keysAndPaths = buildFieldKeysAndPaths(fieldNode, cachedAncestorFieldData, context);
     const {
@@ -407,24 +925,20 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       fragmentName,
       typeName
     } = cachedAncestorFieldData;
-
     CacheManager._setCachedResponseData({
       cacheability,
       data
     }, cachedResponseData, keysAndPaths, {
-      dataTypeName: _get(data, TYPE_NAME_KEY),
-      fieldTypeName: typeName,
+      dataTypename: get(data, TYPE_NAME_KEY),
+      fieldTypename: typeName,
       fragmentKind,
       fragmentName
     }, options, context);
-
-    if (!_isObjectLike(data)) {
+    if (!isObjectLike(data)) {
       return;
     }
-
-    const objectLikeData = data;
     const promises = [];
-    iterateChildFields(fieldNode, objectLikeData, context.fragmentDefinitions, (childField, childTypeName, childFragmentKind, childFragmentName, childIndex) => {
+    iterateChildFields(fieldNode, data, context.fragmentDefinitions, (childField, childTypeName, childFragmentKind, childFragmentName, childIndex) => {
       promises.push(this._analyzeFieldNode(childField, {
         cacheability,
         entityData,
@@ -435,13 +949,13 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
         requestFieldPath,
         requestFieldPathData,
         typeName: childTypeName
-      }, { ...cachedResponseData,
-        data: cachedResponseData.data[propNameOrIndex]
+      }, {
+        ...cachedResponseData,
+        data: getDataValue(cachedResponseData.data, propNameOrIndex)
       }, options, context));
     });
     await Promise.all(promises);
   }
-
   _buildCacheMetadata({
     ast
   }, {
@@ -452,59 +966,49 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       data,
       ...otherProps
     }, context);
-
     const queryNode = getOperationDefinitions(ast, context.operation)[0];
+    if (!queryNode) {
+      return cacheMetadata;
+    }
     const fieldsAndTypeNames = getChildFields(queryNode);
-
     if (!fieldsAndTypeNames) {
       return cacheMetadata;
     }
-
-    fieldsAndTypeNames.forEach(({
+    for (const {
       fieldNode
-    }) => this._setFieldCacheability(fieldNode, {
+    } of fieldsAndTypeNames) this._setFieldCacheability(fieldNode, {
       requestFieldPath: context.operation
     }, {
       cacheMetadata,
       data
-    }, options, context));
+    }, 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)
+        entityData: cloneDeep(data),
+        requestFieldPathData: cloneDeep(data)
       }, options, context));
       let queryCacheMetadata;
       let queryData;
-
-      if (context.operation === QUERY) {
+      if (context.operation === OperationTypeNode.QUERY) {
         let partialQueryResponse;
-
         if (context.queryFiltered && updatedRequestData) {
           dataCaching.push(this._setQueryResponseCacheEntry(updatedRequestData.hash, {
             cacheMetadata,
@@ -512,7 +1016,6 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
           }, options, context));
           partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
         }
-
         queryCacheMetadata = CacheManager._mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse);
         queryData = this._mergeResponseData(data, partialQueryResponse);
         dataCaching.push(this._setQueryResponseCacheEntry(requestData.hash, {
@@ -520,11 +1023,9 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
           data: queryData
         }, options, context));
       }
-
       if (options.awaitDataCaching) {
         await Promise.all(dataCaching);
       }
-
       if (isNotResponseChunk(normalizedResponseData, context) && queryCacheMetadata && queryData) {
         return {
           cacheMetadata: queryCacheMetadata,
@@ -532,7 +1033,6 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
         };
       }
     }
-
     const {
       data,
       hasNext,
@@ -545,30 +1045,24 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       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)) {
+      if (isUndefined(entry)) {
         return false;
       }
-
       return {
         cacheability,
         entry
       };
-    } catch (error) {
+    } catch {
       return false;
     }
   }
-
   _createCacheMetadata({
     _cacheMetadata,
     headers
@@ -582,71 +1076,47 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       headers
     });
     cacheMetadata.set(operation, cacheability);
-
     if (_cacheMetadata) {
       rehydrateCacheMetadata(_cacheMetadata, cacheMetadata);
     }
-
     return cacheMetadata;
   }
-
   async _getCacheEntry(cacheType, hash, _options, _context) {
-    try {
-      return await this._cache.get(`${cacheType}::${hash}`);
-    } catch (errors) {
-      return Promise.reject(errors);
-    }
+    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 (error) {
+    } catch {
       return false;
     }
   }
-
   _isFieldEntity(fieldData, {
     isEntity,
     possibleTypes
   }) {
-    if (!_get(fieldData, this._typeIDKey, null)) {
+    if (!isPlainObject(fieldData) || !(this._typeIDKey in fieldData)) {
       return false;
     }
-
     if (isEntity) {
       return true;
     }
-
-    if (!possibleTypes.length) {
+    if (possibleTypes.length === 0) {
       return false;
     }
-
     return possibleTypes.some(type => type.typeName === fieldData.__typename);
   }
-
-  _mergeObjects(obj, src) {
-    return mergeObjects(obj, src, (_key, val) => {
-      return _isPlainObject(val) && val[this._typeIDKey] ? val[this._typeIDKey] : undefined;
-    });
-  }
-
   _mergeResponseData(responseData, partialQueryResponse) {
     if (!partialQueryResponse) {
       return responseData;
     }
-
-    return this._mergeObjects(partialQueryResponse.data, responseData);
+    return mergeDataSets(partialQueryResponse.data, responseData, this._typeIDKey);
   }
-
   async _parseEntityAndRequestFieldPathCacheEntryData(field, ancestorKeysAndPaths, {
     cacheMetadata,
     entityData,
@@ -658,16 +1128,12 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       requestFieldPath,
       responseDataPath
     } = keysAndPaths;
-
-    const fieldData = _get(requestFieldPathData, responseDataPath);
-
+    const fieldData = get(requestFieldPathData, responseDataPath);
     const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-
-    if (!_isObjectLike(fieldData) && !(fieldTypeInfo !== null && fieldTypeInfo !== void 0 && fieldTypeInfo.hasDirectives)) {
+    if (!isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
       return;
     }
-
-    if (_isObjectLike(fieldData)) {
+    if (isObjectLike(fieldData)) {
       const promises = [];
       iterateChildFields(field, fieldData, context.fragmentDefinitions, (childField, _typeName, _fragmentKind, _fragmentName, childIndex) => {
         promises.push(this._parseEntityAndRequestFieldPathCacheEntryData(childField, {
@@ -683,14 +1149,12 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       });
       await Promise.all(promises);
     }
-
     await this._setEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
       cacheMetadata,
       entityData,
       requestFieldPathData
     }, options, context);
   }
-
   async _retrieveCachedEntityData(validTypeIDValue, {
     possibleTypes,
     typeName
@@ -699,7 +1163,6 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
     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) {
@@ -712,13 +1175,11 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
         cacheability: validResults[0].cacheability,
         entry: validResults.reduce((obj, {
           entry
-        }) => this._mergeObjects(obj, entry), {})
+        }) => mergeDataSets(obj, entry, this._typeIDKey), {})
       };
     }
-
-    return validResult || {};
+    return validResult ?? {};
   }
-
   async _retrieveCachedParentNodeData({
     entityData: ancestorEntityData,
     requestFieldPathData: ancestorRequestFieldPathData
@@ -727,49 +1188,31 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
     propNameOrIndex,
     requestFieldCacheKey
   }, fieldTypeInfo, options, context) {
-    var _entityData;
-
     let entityData = CacheManager._getFieldDataFromAncestor(ancestorEntityData, propNameOrIndex);
-
     let requestFieldPathData = CacheManager._getFieldDataFromAncestor(ancestorRequestFieldPathData, propNameOrIndex);
-
     let cacheability;
-
     if (CacheManager._isNodeRequestFieldPath(fieldTypeInfo)) {
       const {
         cacheability: entryCacheability,
         entry
       } = await this._retrieveCachedRequestFieldPathData(hashedRequestFieldCacheKey, requestFieldCacheKey, options, context);
-
-      if (entry) {
-        requestFieldPathData = this._mergeObjects(requestFieldPathData, entry);
-      }
-
+      requestFieldPathData = combineDataSets(requestFieldPathData, entry, this._typeIDKey);
       if (entryCacheability) {
         cacheability = entryCacheability;
       }
     }
-
-    const validTypeIDValue = getValidTypeIDValue(requestFieldPathData, fieldTypeInfo, this._typeIDKey);
-
+    const validTypeIDValue = getValidTypeIdValue(requestFieldPathData, fieldTypeInfo, this._typeIDKey);
     if (CacheManager._isNodeEntity(fieldTypeInfo) && validTypeIDValue) {
-      var _cacheability;
-
       const {
         cacheability: entryCacheability,
         entry
       } = await this._retrieveCachedEntityData(validTypeIDValue, fieldTypeInfo, options, context);
-
-      if (entry) {
-        entityData = this._mergeObjects(entityData, entry);
-      }
-
-      if (entryCacheability && (!cacheability || entryCacheability.metadata.ttl > ((_cacheability = cacheability) === null || _cacheability === void 0 ? void 0 : _cacheability.metadata.ttl))) {
+      entityData = combineDataSets(entityData, entry, this._typeIDKey);
+      if (entryCacheability && (!cacheability || entryCacheability.metadata.ttl > cacheability.metadata.ttl)) {
         cacheability = entryCacheability;
       }
     }
-
-    const data = !_isUndefined(requestFieldPathData) || !_isUndefined(entityData) ? this._mergeObjects(requestFieldPathData, entityData) : (_entityData = entityData) !== null && _entityData !== void 0 ? _entityData : requestFieldPathData;
+    const data = isEqual(entityData, requestFieldPathData) ? entityData : combineDataSets(entityData, requestFieldPathData, this._typeIDKey);
     return {
       cacheability,
       data,
@@ -777,13 +1220,12 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       requestFieldPathData
     };
   }
-
   async _retrieveCachedRequestFieldPathData(hash, requestFieldCacheKey, options, context) {
-    return this._checkCacheEntry(REQUEST_FIELD_PATHS, hash, options, { ...context,
+    return (await this._checkCacheEntry(REQUEST_FIELD_PATHS, hash, options, {
+      ...context,
       requestFieldCacheKey
-    }) || {};
+    })) || {};
   }
-
   async _retrieveCachedResponseData({
     ast
   }, options, context) {
@@ -797,12 +1239,13 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       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, {
@@ -811,29 +1254,25 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
     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 (error) {}
+      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
     }) => {
@@ -842,7 +1281,6 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       }, responseData, options, context);
     }));
   }
-
   async _setEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
     cacheMetadata,
     entityData,
@@ -852,29 +1290,22 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       requestFieldPath,
       responseDataPath
     } = keysAndPaths;
-
-    const fieldData = _get(entityData, responseDataPath);
-
+    const fieldData = get(entityData, responseDataPath);
     const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
     const cacheability = cacheMetadata.get(requestFieldPath);
-
-    if (_isUndefined(fieldData) || !fieldTypeInfo || !cacheability) {
+    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);
+      unset(entityData, responseDataPath);
     }
-
     if (isEntity) {
       promises.push(this._setEntityCacheEntry(keysAndPaths, {
         cacheability,
@@ -882,10 +1313,8 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
         fieldTypeInfo
       }, options, context));
     }
-
     await Promise.all(promises);
   }
-
   async _setEntityCacheEntry({
     responseDataPath
   }, {
@@ -893,28 +1322,23 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
     data,
     fieldTypeInfo
   }, options, context) {
-    let fieldData = _get(data, responseDataPath);
-
+    let fieldData = get(data, responseDataPath);
     const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
-    const entityDataKey = `${fieldTypeName}::${fieldData[this._typeIDKey]}`;
+    const entityDataKey = `${fieldTypeName}::${String(fieldData[this._typeIDKey])}`;
     const result = await this._checkCacheEntry(DATA_ENTITIES, entityDataKey, options, context);
-
     if (result) {
-      fieldData = this._mergeObjects(result.entry, fieldData);
+      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, {
+    set(data, responseDataPath, {
       __cacheKey: `${DATA_ENTITIES}::${entityDataKey}`
     });
   }
-
   _setFieldCacheability(field, ancestorKeysAndPaths, {
     cacheMetadata,
     data
@@ -927,21 +1351,19 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       requestFieldPath,
       responseDataPath
     } = keysAndPaths;
-
-    const fieldData = _get(data, responseDataPath);
-
+    if (!isObjectLike(data)) {
+      return;
+    }
+    const fieldData = get(data, responseDataPath);
     const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-
-    if (!_isObjectLike(fieldData) && !(fieldTypeInfo !== null && fieldTypeInfo !== void 0 && fieldTypeInfo.hasDirectives)) {
+    if (!isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
       return;
     }
-
     this._setFieldTypeCacheDirective(cacheMetadata, {
       ancestorRequestFieldPath,
       requestFieldPath
     }, context);
-
-    if (_isObjectLike(fieldData)) {
+    if (isObjectLike(fieldData)) {
       iterateChildFields(field, fieldData, context.fragmentDefinitions, (childField, _typeName, _fragmentKind, _fragmentName, childIndex) => {
         this._setFieldCacheability(childField, {
           index: childIndex,
@@ -954,7 +1376,6 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       });
     }
   }
-
   _setFieldTypeCacheDirective(cacheMetadata, {
     ancestorRequestFieldPath,
     requestFieldPath
@@ -965,32 +1386,25 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
     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);
     }
   }
-
-  async _setPartialQueryResponse(hash, partialQueryResponse, _options, _context) {
+  _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
@@ -1001,7 +1415,6 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       tag: options.tag
     }, options, context);
   }
-
   async _setRequestFieldPathCacheEntry(field, keysAndPaths, {
     cacheability,
     data,
@@ -1012,61 +1425,51 @@ let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = log
       requestFieldCacheKey,
       responseDataPath
     } = keysAndPaths;
-
-    let fieldData = _get(data, responseDataPath);
-
+    let fieldData = get(data, responseDataPath);
     const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
-
     const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
-
-    if (context.operation === QUERY && (isEntity || hasArgsOrDirectives)) {
-      var _field$selectionSet;
-
-      if (_isPlainObject(fieldData) && (_field$selectionSet = field.selectionSet) !== null && _field$selectionSet !== void 0 && _field$selectionSet.selections) {
+    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,
+      const result = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, {
+        ...context,
         requestFieldCacheKey
       });
-
-      if (result && _isObjectLike(fieldData)) {
-        fieldData = this._mergeObjects(result.entry, fieldData);
+      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,
+      }, options, {
+        ...context,
         requestFieldCacheKey
       });
-
       if (hasChildFields(field, {
         fragmentDefinitions: context.fragmentDefinitions
       })) {
         if (isEntity) {
-          _set(data, responseDataPath, {
+          set(data, responseDataPath, {
             __cacheKey: `${REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}`
           });
         } else {
-          _unset(data, responseDataPath);
+          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 as default };
-//# sourceMappingURL=index.js.map
+
+export { CacheManager };
+//# sourceMappingURL=index.mjs.map