@graphql-box/cache-manager 2.1.2 → 2.3.0

package/lib/module/main/index.js

@@ -5,20 +5,26 @@ import _set from "lodash/set";
 import _isUndefined from "lodash/isUndefined";
 import _isPlainObject from "lodash/isPlainObject";
 import _isObjectLike from "lodash/isObjectLike";
-import _isNumber from "lodash/isNumber";
 import _isArray from "lodash/isArray";
 import _get from "lodash/get";
 import _cloneDeep from "lodash/cloneDeep";
+import _assign from "lodash/assign";
 
 var _dec, _dec2, _dec3, _class;
 
 import "core-js/modules/es.promise.js";
 import { DATA_ENTITIES, QUERY, QUERY_RESPONSES, REQUEST_FIELD_PATHS, TYPE_NAME_KEY } from "@graphql-box/core";
-import { dehydrateCacheMetadata, deleteChildFields, deleteInlineFragments, getAlias, getArguments, getChildFields, getDirectives, getInlineFragments, getName, getOperationDefinitions, hasChildFields, hashRequest, iterateChildFields, mergeObjects, rehydrateCacheMetadata } from "@graphql-box/helpers";
+import { FRAGMENT_SPREAD, 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_CACHE_CONTROL, HEADER_NO_CACHE, METADATA, NO_CACHE } from "../consts";
+import { CACHE_CONTROL, HEADER_NO_CACHE, METADATA, NO_CACHE } from "../consts";
 import { logCacheEntry, logCacheQuery, logPartialCompiled } from "../debug";
+import { buildFieldKeysAndPaths } from "../helpers/buildKeysAndPaths";
+import deriveOpCacheability from "../helpers/deriveOpCacheability";
+import filterOutPropsWithArgsOrDirectives from "../helpers/filterOutPropsWithArgsOrDirectives";
+import filterQuery from "../helpers/filterQuery";
+import normalizeResponseData from "../helpers/normalizeResponseData";
+import { getValidTypeIDValue } from "../helpers/validTypeIDValue";
 export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = logPartialCompiled(), (_class = class CacheManager {
   static async init(options) {
     const errors = [];
@@ -32,85 +38,11 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
       errors.push(new TypeError(message));
     }
 
-    if (errors.length) return Promise.reject(errors);
-    return new CacheManager(options);
-  }
-
-  static _analyzeLeafField(field, cachedAncestorFieldData, {
-    data,
-    fieldPathChecklist
-  }, _options, _context) {
-    const keysAndPaths = CacheManager._getFieldKeysAndPaths(field, cachedAncestorFieldData);
-
-    const {
-      propNameOrIndex,
-      requestFieldPath
-    } = keysAndPaths;
-    const {
-      dataEntityData,
-      requestFieldPathData,
-      typeName
-    } = cachedAncestorFieldData;
-
-    const cachedFieldData = CacheManager._getFieldDataFromAncestor(dataEntityData, propNameOrIndex) || CacheManager._getFieldDataFromAncestor(requestFieldPathData, propNameOrIndex);
-
-    const typeNames = {
-      dataTypeName: dataEntityData.__typename || requestFieldPathData.__typename,
-      fieldTypeName: typeName
-    };
-
-    CacheManager._setFieldPathChecklist(fieldPathChecklist, {
-      data: cachedFieldData
-    }, requestFieldPath, typeNames);
-
-    CacheManager._setCachedData(data, {
-      data: cachedFieldData
-    }, propNameOrIndex);
-  }
-
-  static _buildKey(key, path) {
-    const paths = [];
-    if (path.length) paths.push(path);
-    paths.push(key);
-    return paths.join(".");
-  }
-
-  static _buildRequestFieldCacheKey(name, requestFieldCacheKey, args, directives, index) {
-    let key = `${_isNumber(index) ? index : name}`;
-    if (args) key = `${key}(${JSON.stringify(args)})`;
-    if (directives) key = `${key}(${JSON.stringify(directives)})`;
-    return CacheManager._buildKey(key, requestFieldCacheKey);
-  }
-
-  static _checkFieldPathChecklist(fieldPathChecklistValues, fieldTypeName) {
-    if (!fieldPathChecklistValues || !fieldPathChecklistValues.length) {
-      return {
-        hasData: false,
-        typeUnused: !!fieldTypeName
-      };
-    }
-
-    if (fieldPathChecklistValues.length === 1) {
-      const {
-        hasData,
-        typeName
-      } = fieldPathChecklistValues[0];
-      const typeUnused = !typeName ? undefined : typeName !== fieldTypeName;
-      return {
-        hasData,
-        typeUnused
-      };
+    if (errors.length) {
+      return Promise.reject(errors);
     }
 
-    return {
-      hasData: fieldPathChecklistValues.some(({
-        hasData,
-        typeName
-      }) => typeName === fieldTypeName && hasData),
-      typeUnused: !fieldPathChecklistValues.every(({
-        typeName
-      }) => typeName === fieldTypeName)
-    };
+    return new CacheManager(options);
   }
 
   static _countFieldPathChecklist(fieldPathChecklist) {
@@ -129,49 +61,33 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
   }
 
   static _getFieldDataFromAncestor(ancestorFieldData, propNameOrIndex) {
-    return _isObjectLike(ancestorFieldData) ? ancestorFieldData[propNameOrIndex] : undefined;
-  }
-
-  static _getFieldKeysAndPaths(field, options) {
-    const {
-      index,
-      requestFieldCacheKey = "",
-      requestFieldPath = "",
-      responseDataPath = ""
-    } = options;
-    const name = getName(field);
-
-    const updatedRequestFieldCacheKey = CacheManager._buildRequestFieldCacheKey(name, requestFieldCacheKey, getArguments(field), getDirectives(field), index);
-
-    const fieldAliasOrName = getAlias(field) || name;
-    const updatedRequestFieldPath = _isNumber(index) ? requestFieldPath : CacheManager._buildKey(fieldAliasOrName, requestFieldPath);
-    const propNameOrIndex = _isNumber(index) ? index : fieldAliasOrName;
-
-    const updatedResponseDataPath = CacheManager._buildKey(propNameOrIndex, responseDataPath);
-
-    return {
-      hashedRequestFieldCacheKey: hashRequest(updatedRequestFieldCacheKey),
-      propNameOrIndex,
-      requestFieldCacheKey: updatedRequestFieldCacheKey,
-      requestFieldPath: updatedRequestFieldPath,
-      responseDataPath: updatedResponseDataPath
-    };
+    return _isObjectLike(ancestorFieldData) ? _cloneDeep(ancestorFieldData[propNameOrIndex]) : undefined;
   }
 
   static _getOperationCacheControl(cacheMetadata, operation) {
     const defaultCacheControl = HEADER_NO_CACHE;
-    if (!cacheMetadata) return defaultCacheControl;
+
+    if (!cacheMetadata) {
+      return defaultCacheControl;
+    }
+
     const cacheability = cacheMetadata.get(operation);
     return cacheability ? cacheability.printCacheControl() : defaultCacheControl;
   }
 
   static _getResponseCacheMetadata(cacheMetadata, partialQueryResponse) {
-    if (!partialQueryResponse) return cacheMetadata;
+    if (!partialQueryResponse) {
+      return cacheMetadata;
+    }
+
     return new Map([...partialQueryResponse.cacheMetadata, ...cacheMetadata]);
   }
 
-  static _isDataEntity(fieldTypeInfo) {
-    if (!fieldTypeInfo) return false;
+  static _isNodeEntity(fieldTypeInfo) {
+    if (!fieldTypeInfo) {
+      return false;
+    }
+
     const {
       isEntity,
       possibleTypes
@@ -179,8 +95,8 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     return isEntity || possibleTypes.some(type => !!type.isEntity);
   }
 
-  static _isRequestFieldPath(fieldTypeInfo) {
-    return !!fieldTypeInfo && (this._isDataEntity(fieldTypeInfo) || fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives);
+  static _isNodeRequestFieldPath(fieldTypeInfo) {
+    return !!fieldTypeInfo && (this._isNodeEntity(fieldTypeInfo) || fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives);
   }
 
   static _isValid(cacheability) {
@@ -207,18 +123,21 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
   }, {
     propNameOrIndex,
     requestFieldPath
-  }, typeNames, _options, {
+  }, typeNamesAndKind, _options, {
     operation
   }) {
     CacheManager._setCacheMetadata(cacheMetadata, cachedFieldData.cacheability, requestFieldPath, operation);
 
-    CacheManager._setFieldPathChecklist(fieldPathChecklist, cachedFieldData, requestFieldPath, typeNames);
+    CacheManager._setFieldPathChecklist(fieldPathChecklist, cachedFieldData, requestFieldPath, typeNamesAndKind);
 
     CacheManager._setCachedData(data, cachedFieldData, propNameOrIndex);
   }
 
   static _setCacheMetadata(cacheMetadata, cacheability, requestFieldPath, operation) {
-    if (!cacheability) return;
+    if (!cacheability) {
+      return;
+    }
+
     cacheMetadata.set(requestFieldPath, cacheability);
     const operationCacheability = cacheMetadata.get(operation);
 
@@ -231,23 +150,39 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     data
   }, requestFieldPath, {
     dataTypeName,
-    fieldTypeName
+    fieldTypeName,
+    fragmentKind,
+    fragmentName
   }) {
-    if (_isUndefined(fieldTypeName)) {
-      if (fieldPathChecklist.has(requestFieldPath)) return;
+    if (_isUndefined(fieldTypeName) || fragmentKind === FRAGMENT_SPREAD) {
+      if (fieldPathChecklist.has(requestFieldPath)) {
+        return;
+      }
+
       fieldPathChecklist.set(requestFieldPath, [{
+        fragmentKind,
+        fragmentName,
         hasData: !_isUndefined(data)
       }]);
       return;
     }
 
-    if (dataTypeName !== fieldTypeName) return;
+    if (dataTypeName !== fieldTypeName) {
+      return;
+    }
+
     const entry = fieldPathChecklist.get(requestFieldPath);
     const checklistValues = entry ? entry : [];
+
     if (checklistValues.some(({
       typeName
-    }) => typeName === dataTypeName)) return;
+    }) => typeName === dataTypeName)) {
+      return;
+    }
+
     fieldPathChecklist.set(requestFieldPath, [...checklistValues, {
+      fragmentKind,
+      fragmentName,
       hasData: !_isUndefined(data),
       typeName: dataTypeName
     }]);
@@ -294,23 +229,33 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
       return Promise.reject(new TypeError("@graphql-box/cache-manager expected an AST."));
     }
 
-    const cachedResponseData = await this._getCachedResponseData(requestData, options, context);
+    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) return {
-      updated: requestData
-    };
+
+    if (fieldCount.missing === fieldCount.total) {
+      return {
+        updated: requestData
+      };
+    }
 
     if (!fieldCount.missing) {
       const dataCaching = this._setQueryResponseCacheEntry(hash, {
         cacheMetadata,
         data
-      }, options, context);
+      }, options, cacheManagerContext);
+
+      if (options.awaitDataCaching) {
+        await dataCaching;
+      }
 
-      if (options.awaitDataCaching) await dataCaching;
       return {
         response: {
           cacheMetadata,
@@ -322,14 +267,21 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     this._setPartialQueryResponse(hash, {
       cacheMetadata,
       data
-    }, options, context);
+    }, options, cacheManagerContext);
 
-    this._filterQuery(requestData, cachedResponseData, context);
+    const filteredAST = filterQuery(requestData, cachedResponseData, cacheManagerContext);
+    const {
+      fragmentDefinitions,
+      typeIDKey,
+      ...rest
+    } = cacheManagerContext;
+
+    _assign(context, rest);
 
-    const request = print(ast);
+    const request = print(filteredAST);
     return {
       updated: {
-        ast,
+        ast: filteredAST,
         hash: hashRequest(request),
         request
       }
@@ -342,7 +294,11 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
 
   async checkQueryResponseCacheEntry(hash, options, context) {
     const result = await this._checkCacheEntry(QUERY_RESPONSES, hash, options, context);
-    if (!result) return false;
+
+    if (!result) {
+      return false;
+    }
+
     const {
       cacheMetadata,
       data
@@ -358,18 +314,23 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
   }
 
   async resolveQuery(requestData, updatedRequestData, rawResponseData, options, context) {
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: getFragmentDefinitions(updatedRequestData.ast),
+      typeIDKey: this._typeIDKey
+    };
     const dataCaching = [];
     const {
       cacheMetadata,
-      data
-    } = await this._resolveRequest(updatedRequestData, rawResponseData, options, context);
+      data,
+      hasNext
+    } = await this._resolveRequest(updatedRequestData, rawResponseData, options, cacheManagerContext);
     let partialQueryResponse;
 
-    if (context.queryFiltered) {
+    if (cacheManagerContext.queryFiltered) {
       dataCaching.push(this._setQueryResponseCacheEntry(updatedRequestData.hash, {
         cacheMetadata,
         data
-      }, options, context));
+      }, options, cacheManagerContext));
       partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
     }
 
@@ -380,79 +341,127 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     dataCaching.push(this._setQueryResponseCacheEntry(requestData.hash, {
       cacheMetadata: responseCacheMetadata,
       data: responseData
-    }, options, context));
-    if (options.awaitDataCaching) await Promise.all(dataCaching);
+    }, options, cacheManagerContext));
+
+    if (options.awaitDataCaching) {
+      await Promise.all(dataCaching);
+    }
+
     return {
       cacheMetadata: responseCacheMetadata,
-      data: responseData
+      data: responseData,
+      hasNext
     };
   }
 
   async resolveRequest(requestData, rawResponseData, options, context) {
-    return this._resolveRequest(requestData, rawResponseData, options, context);
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: getFragmentDefinitions(requestData.ast),
+      typeIDKey: this._typeIDKey
+    };
+    return this._resolveRequest(requestData, rawResponseData, options, cacheManagerContext);
   }
 
-  async _analyzeField(field, cachedAncestorFieldData, cachedResponseData, options, context) {
-    if (hasChildFields(field)) {
-      await this._analyzeParentField(field, cachedAncestorFieldData, cachedResponseData, options, context);
+  async _analyzeFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
+    if (hasChildFields(fieldNode)) {
+      await this._analyzeParentFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
     } else {
-      await CacheManager._analyzeLeafField(field, cachedAncestorFieldData, cachedResponseData, options, context);
+      await this._analyzeLeafFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
     }
   }
 
-  async _analyzeParentField(field, cachedAncestorFieldData, cachedResponseData, options, context) {
-    const keysAndPaths = CacheManager._getFieldKeysAndPaths(field, cachedAncestorFieldData);
-
+  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 {
-      dataEntityData: ancestorDataEntityData,
-      requestFieldPathData: ancestorRequestFieldPathData,
+      entityData,
+      fragmentKind,
+      fragmentName,
+      requestFieldPathData,
       typeName
     } = cachedAncestorFieldData;
-    const cachedFieldData = {
-      dataEntityData: CacheManager._getFieldDataFromAncestor(ancestorDataEntityData, propNameOrIndex),
-      requestFieldPathData: CacheManager._getFieldDataFromAncestor(ancestorRequestFieldPathData, propNameOrIndex)
+    const typeNamesAndKind = {
+      dataTypeName: (entityData === null || entityData === void 0 ? void 0 : entityData.__typename) || (requestFieldPathData === null || requestFieldPathData === void 0 ? void 0 : requestFieldPathData.__typename),
+      fieldTypeName: typeName,
+      fragmentKind,
+      fragmentName
     };
 
-    if (CacheManager._isRequestFieldPath(fieldTypeInfo)) {
-      await this._setRequestFieldPathData(cachedFieldData, hashedRequestFieldCacheKey, options, context);
-    }
+    if (CacheManager._isNodeRequestFieldPath(fieldTypeInfo)) {
+      const {
+        cacheability,
+        entry
+      } = await this._retrieveCachedRequestFieldPathData(hashedRequestFieldCacheKey, options, context);
 
-    if (CacheManager._isDataEntity(fieldTypeInfo)) {
-      await this._setDataEntityData(cachedFieldData, fieldTypeInfo, 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,
-      dataEntityData,
+      data,
+      entityData,
       requestFieldPathData
-    } = cachedFieldData;
-    const data = !_isUndefined(requestFieldPathData) || !_isUndefined(dataEntityData) ? this._mergeObjects(requestFieldPathData, dataEntityData) : undefined;
+    } = 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
+      fieldTypeName: typeName,
+      fragmentKind,
+      fragmentName
     }, options, context);
 
-    if (!_isObjectLike(data)) return;
+    if (!_isObjectLike(data)) {
+      return;
+    }
+
     const objectLikeData = data;
     const promises = [];
-    iterateChildFields(field, objectLikeData, (childField, childTypeName, childIndex) => {
-      promises.push(this._analyzeField(childField, {
+    iterateChildFields(fieldNode, objectLikeData, context.fragmentDefinitions, (childField, childTypeName, childFragmentKind, childFragmentName, childIndex) => {
+      promises.push(this._analyzeFieldNode(childField, {
+        cacheability,
+        entityData,
+        fragmentKind: childFragmentKind,
+        fragmentName: childFragmentName,
         index: childIndex,
         requestFieldCacheKey,
         requestFieldPath,
-        typeName: childTypeName,
-        ...cachedFieldData
+        requestFieldPathData,
+        typeName: childTypeName
       }, { ...cachedResponseData,
         data: cachedResponseData.data[propNameOrIndex]
       }, options, context));
@@ -473,7 +482,11 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
 
     const queryNode = getOperationDefinitions(ast, context.operation)[0];
     const fieldsAndTypeNames = getChildFields(queryNode);
-    if (!fieldsAndTypeNames) return cacheMetadata;
+
+    if (!fieldsAndTypeNames) {
+      return cacheMetadata;
+    }
+
     fieldsAndTypeNames.forEach(({
       fieldNode
     }) => this._setFieldCacheability(fieldNode, {
@@ -488,9 +501,17 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
   async _checkCacheEntry(cacheType, hash, options, context) {
     try {
       const cacheability = await this._hasCacheEntry(cacheType, hash);
-      if (!cacheability || !CacheManager._isValid(cacheability)) return false;
+
+      if (!cacheability || !CacheManager._isValid(cacheability)) {
+        return false;
+      }
+
       const entry = await this._getCacheEntry(cacheType, hash, options, context);
-      if (!entry) return false;
+
+      if (_isUndefined(entry)) {
+        return false;
+      }
+
       return {
         cacheability,
         entry
@@ -507,157 +528,18 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     operation
   }) {
     const cacheMetadata = new Map();
-
-    const cacheControl = headers && headers.get(HEADER_CACHE_CONTROL) || this._fallbackOperationCacheability;
-
-    const cacheability = new Cacheability({
-      cacheControl
+    const cacheability = deriveOpCacheability({
+      _cacheMetadata,
+      fallback: this._fallbackOperationCacheability,
+      headers
     });
     cacheMetadata.set(operation, cacheability);
-    if (_cacheMetadata) rehydrateCacheMetadata(_cacheMetadata, cacheMetadata);
-    return cacheMetadata;
-  }
-
-  _filterField(field, fieldPathChecklist, ancestorRequestFieldPath, context) {
-    const fieldsAndTypeNames = getChildFields(field);
-    if (!fieldsAndTypeNames) return false;
-
-    for (let i = fieldsAndTypeNames.length - 1; i >= 0; i -= 1) {
-      const {
-        fieldNode: childField,
-        typeName: childTypeName
-      } = fieldsAndTypeNames[i];
-      const childFieldName = getName(childField);
-      if (childFieldName === this._typeIDKey || childFieldName === TYPE_NAME_KEY) continue;
-
-      const {
-        requestFieldPath
-      } = CacheManager._getFieldKeysAndPaths(childField, {
-        requestFieldPath: ancestorRequestFieldPath
-      });
-
-      const {
-        hasData,
-        typeUnused
-      } = CacheManager._checkFieldPathChecklist(fieldPathChecklist.get(requestFieldPath), childTypeName);
-
-      if (hasData || typeUnused) {
-        if (!hasChildFields(childField)) {
-          deleteChildFields(field, childField);
-        } else if (this._filterField(childField, fieldPathChecklist, requestFieldPath, context)) {
-          deleteChildFields(field, childField);
-        }
-      }
-    }
-
-    this._filterInlineFragments(field);
-
-    this._filterIDsAndTypeNames(field);
-
-    return !hasChildFields(field);
-  }
-
-  _filterIDsAndTypeNames(field) {
-    const fieldsAndTypeNames = getChildFields(field);
-    if (!fieldsAndTypeNames || fieldsAndTypeNames.length > 3) return false;
-    const fieldNames = fieldsAndTypeNames.map(({
-      fieldNode
-    }) => getName(fieldNode));
-
-    if (fieldNames.length === 2 && fieldNames.every(name => name === this._typeIDKey || name === TYPE_NAME_KEY)) {
-      deleteChildFields(field, fieldsAndTypeNames.map(({
-        fieldNode
-      }) => fieldNode));
-      return true;
-    }
-
-    if (fieldNames.length === 1 && fieldNames[0] === this._typeIDKey || fieldNames[0] === TYPE_NAME_KEY) {
-      const {
-        fieldNode
-      } = fieldsAndTypeNames[0];
-      deleteChildFields(field, fieldNode);
-      return true;
-    }
-
-    return false;
-  }
-
-  _filterInlineFragments(field) {
-    const inlineFragments = getInlineFragments(field);
-    let filtered = false;
-    inlineFragments.forEach(fragment => {
-      const fieldsAndTypeNames = getChildFields(fragment);
-
-      if (!fieldsAndTypeNames || !fieldsAndTypeNames.length) {
-        deleteInlineFragments(field, fragment);
-        filtered = true;
-        return;
-      }
-
-      if (fieldsAndTypeNames.length === 1) {
-        const {
-          fieldNode
-        } = fieldsAndTypeNames[0];
-
-        if (getName(fieldNode) === this._typeIDKey) {
-          deleteInlineFragments(field, fragment);
-          filtered = true;
-        }
-      }
-    });
-    return filtered;
-  }
-
-  _filterQuery({
-    ast
-  }, {
-    fieldPathChecklist
-  }, context) {
-    const queryNode = getOperationDefinitions(ast, context.operation)[0];
-    const fieldsAndTypeNames = getChildFields(queryNode);
-    if (!fieldsAndTypeNames) return;
-
-    for (let i = fieldsAndTypeNames.length - 1; i >= 0; i -= 1) {
-      const {
-        fieldNode
-      } = fieldsAndTypeNames[i];
-
-      const {
-        requestFieldPath
-      } = CacheManager._getFieldKeysAndPaths(fieldNode, {
-        requestFieldPath: context.operation
-      });
 
-      if (this._filterField(fieldNode, fieldPathChecklist, requestFieldPath, context)) {
-        deleteChildFields(queryNode, fieldNode);
-      }
+    if (_cacheMetadata) {
+      rehydrateCacheMetadata(_cacheMetadata, cacheMetadata);
     }
 
-    context.queryFiltered = true;
-  }
-
-  async _getCachedResponseData({
-    ast
-  }, options, context) {
-    const cachedResponseData = {
-      cacheMetadata: new Map(),
-      data: {},
-      fieldCount: {
-        missing: 0,
-        total: 0
-      },
-      fieldPathChecklist: new Map()
-    };
-    const queryNode = getOperationDefinitions(ast, context.operation)[0];
-    const fieldsAndTypeNames = getChildFields(queryNode);
-    if (!fieldsAndTypeNames) return cachedResponseData;
-    await Promise.all(fieldsAndTypeNames.map(({
-      fieldNode
-    }) => this._analyzeField(fieldNode, {
-      requestFieldPath: context.operation
-    }, cachedResponseData, options, context)));
-    cachedResponseData.fieldCount = CacheManager._countFieldPathChecklist(cachedResponseData.fieldPathChecklist);
-    return cachedResponseData;
+    return cacheMetadata;
   }
 
   async _getCacheEntry(cacheType, hash, _options, _context) {
@@ -677,7 +559,10 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
   }
 
   _getResponseData(responseData, partialQueryResponse) {
-    if (!partialQueryResponse) return responseData;
+    if (!partialQueryResponse) {
+      return responseData;
+    }
+
     return this._mergeObjects(partialQueryResponse.data, responseData);
   }
 
@@ -693,9 +578,18 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     isEntity,
     possibleTypes
   }) {
-    if (!_get(fieldData, this._typeIDKey, null)) return false;
-    if (isEntity) return true;
-    if (!possibleTypes.length) return false;
+    if (!_get(fieldData, this._typeIDKey, null)) {
+      return false;
+    }
+
+    if (isEntity) {
+      return true;
+    }
+
+    if (!possibleTypes.length) {
+      return false;
+    }
+
     return possibleTypes.some(type => type.typeName === fieldData.__typename);
   }
 
@@ -705,159 +599,288 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     });
   }
 
-  async _parseFieldDataEntityAndRequestFieldPathCacheEntryData(field, ancestorKeysAndPaths, {
+  async _parseEntityAndRequestFieldPathCacheEntryData(field, ancestorKeysAndPaths, {
     cacheMetadata,
-    dataEntityData,
+    entityData,
     requestFieldPathData
   }, options, context) {
-    const keysAndPaths = CacheManager._getFieldKeysAndPaths(field, ancestorKeysAndPaths);
-
+    const keysAndPaths = buildFieldKeysAndPaths(field, ancestorKeysAndPaths, context);
     const {
       requestFieldCacheKey,
       requestFieldPath,
       responseDataPath
     } = keysAndPaths;
 
-    const fieldData = _get(requestFieldPathData, responseDataPath, null);
+    const fieldData = _get(requestFieldPathData, responseDataPath);
 
-    if (!_isObjectLike(fieldData)) return;
-    const objectLikeFieldData = fieldData;
-    const promises = [];
-    iterateChildFields(field, objectLikeFieldData, (childField, _typeName, childIndex) => {
-      promises.push(this._parseFieldDataEntityAndRequestFieldPathCacheEntryData(childField, {
-        index: childIndex,
-        requestFieldCacheKey,
-        requestFieldPath,
-        responseDataPath
-      }, {
-        cacheMetadata,
-        dataEntityData,
-        requestFieldPathData
-      }, options, context));
-    });
-    await Promise.all(promises);
-    await this._setFieldDataEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+
+    if (!_isObjectLike(fieldData) && !(fieldTypeInfo !== null && fieldTypeInfo !== void 0 && 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,
-      dataEntityData,
+      entityData,
       requestFieldPathData
     }, options, context);
   }
 
   async _resolveRequest(requestData, rawResponseData, options, context) {
+    const normalizedResponseData = rawResponseData.path ? normalizeResponseData(rawResponseData) : rawResponseData;
     const dataCaching = [];
 
-    const cacheMetadata = this._buildCacheMetadata(requestData, rawResponseData, options, context);
+    const cacheMetadata = this._buildCacheMetadata(requestData, normalizedResponseData, options, context);
 
     const {
-      data
-    } = rawResponseData;
-    dataCaching.push(this._setDataEntityAndRequestFieldPathCacheEntries(requestData, {
+      data,
+      hasNext
+    } = normalizedResponseData;
+    dataCaching.push(this._setEntityAndRequestFieldPathCacheEntries(requestData, {
       cacheMetadata,
-      dataEntityData: _cloneDeep(data),
+      entityData: _cloneDeep(data),
       requestFieldPathData: _cloneDeep(data)
     }, options, context));
-    if (options.awaitDataCaching) await Promise.all(dataCaching);
+
+    if (options.awaitDataCaching) {
+      await Promise.all(dataCaching);
+    }
+
     return {
       cacheMetadata,
-      data
+      data,
+      hasNext
+    };
+  }
+
+  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
+        }) => this._mergeObjects(obj, entry), {})
+      };
+    }
+
+    return validResult || {};
+  }
+
+  async _retrieveCachedParentNodeData({
+    entityData: ancestorEntityData,
+    requestFieldPathData: ancestorRequestFieldPathData
+  }, {
+    hashedRequestFieldCacheKey,
+    propNameOrIndex
+  }, 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, options, context);
+
+      if (entry) {
+        requestFieldPathData = this._mergeObjects(requestFieldPathData, entry);
+      }
+
+      if (entryCacheability) {
+        cacheability = entryCacheability;
+      }
+    }
+
+    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))) {
+        cacheability = entryCacheability;
+      }
+    }
+
+    const data = !_isUndefined(requestFieldPathData) || !_isUndefined(entityData) ? this._mergeObjects(requestFieldPathData, entityData) : (_entityData = entityData) !== null && _entityData !== void 0 ? _entityData : requestFieldPathData;
+    return {
+      cacheability,
+      data,
+      entityData,
+      requestFieldPathData
     };
   }
 
+  async _retrieveCachedRequestFieldPathData(hash, options, context) {
+    return this._checkCacheEntry(REQUEST_FIELD_PATHS, hash, options, context) || {};
+  }
+
+  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];
+    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;
+  }
+
   async _setCacheEntry(cacheType, hash, value, cachemapOptions, _options, _context) {
     try {
       await this._cache.set(`${cacheType}::${hash}`, _cloneDeep(value), cachemapOptions);
     } catch (error) {}
   }
 
-  async _setDataEntityAndRequestFieldPathCacheEntries(requestData, responseData, options, context) {
+  async _setEntityAndRequestFieldPathCacheEntries(requestData, responseData, options, context) {
     const operationNode = getOperationDefinitions(requestData.ast, context.operation)[0];
     const fieldsAndTypeNames = getChildFields(operationNode);
-    if (!fieldsAndTypeNames) return;
+
+    if (!fieldsAndTypeNames) {
+      return;
+    }
+
     await Promise.all(fieldsAndTypeNames.map(({
       fieldNode
     }) => {
-      return this._parseFieldDataEntityAndRequestFieldPathCacheEntryData(fieldNode, {
+      return this._parseEntityAndRequestFieldPathCacheEntryData(fieldNode, {
         requestFieldPath: context.operation
       }, responseData, options, context);
     }));
   }
 
-  async _setDataEntityCacheEntry({
-    responseDataPath
-  }, {
-    cacheability,
-    data,
-    fieldTypeInfo
+  async _setEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
+    cacheMetadata,
+    entityData,
+    requestFieldPathData
   }, options, context) {
-    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
+    const {
+      requestFieldPath,
+      responseDataPath
+    } = keysAndPaths;
 
-    let fieldData = _get(data, responseDataPath, null);
+    const fieldData = _get(entityData, responseDataPath);
 
-    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+    const cacheability = cacheMetadata.get(requestFieldPath);
 
-    if (!isEntity && hasArgsOrDirectives) {
-      _unset(data, responseDataPath);
+    if (_isUndefined(fieldData) || !fieldTypeInfo || !cacheability) {
+      return;
     }
 
-    if (isEntity) {
-      const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
-      const entityDataKey = `${fieldTypeName}::${fieldData[this._typeIDKey]}`;
-      const result = await this._checkCacheEntry(DATA_ENTITIES, entityDataKey, options, context);
+    const promises = [];
+    promises.push(this._setRequestFieldPathCacheEntry(field, keysAndPaths, {
+      cacheability,
+      data: requestFieldPathData,
+      fieldTypeInfo
+    }, options, context));
 
-      if (result) {
-        fieldData = this._mergeObjects(result.entry, fieldData);
-      }
+    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
 
-      await this._setCacheEntry(DATA_ENTITIES, entityDataKey, fieldData, {
-        cacheHeaders: {
-          cacheControl: cacheability.printCacheControl()
-        },
-        tag: options.tag
-      }, options, context);
+    if (!isEntity && fieldTypeInfo.hasArguments) {
+      _unset(entityData, responseDataPath);
+    }
 
-      _set(data, responseDataPath, {
-        __cacheKey: `${DATA_ENTITIES}::${entityDataKey}`
-      });
+    if (isEntity) {
+      promises.push(this._setEntityCacheEntry(keysAndPaths, {
+        cacheability,
+        data: entityData,
+        fieldTypeInfo
+      }, options, context));
     }
+
+    await Promise.all(promises);
   }
 
-  async _setDataEntityData(cachedFieldData, {
-    possibleTypes,
-    typeIDValue,
-    typeName
+  async _setEntityCacheEntry({
+    responseDataPath
+  }, {
+    cacheability,
+    data,
+    fieldTypeInfo
   }, options, context) {
-    const requestFieldPathDataIDValue = _isPlainObject(cachedFieldData.requestFieldPathData) ? cachedFieldData.requestFieldPathData[this._typeIDKey] : undefined;
-    const validTypeIDValue = typeIDValue || requestFieldPathDataIDValue;
-    if (!validTypeIDValue) return;
-    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;
+    let fieldData = _get(data, responseDataPath);
 
-    if (validResults.length === 1) {
-      validResult = validResults[0];
-    } else if (validResults.length > 1) {
-      validResults.sort(({
-        cacheability: a
-      }, {
-        cacheability: b
-      }) => a.metadata.ttl - b.metadata.ttl);
-      validResult = {
-        cacheability: validResults[0].cacheability,
-        entry: validResults.reduce((obj, {
-          entry
-        }) => this._mergeObjects(obj, entry), {})
-      };
-    }
+    const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
+    const entityDataKey = `${fieldTypeName}::${fieldData[this._typeIDKey]}`;
+    const result = await this._checkCacheEntry(DATA_ENTITIES, entityDataKey, options, context);
 
-    if (validResult) {
-      const {
-        cacheability,
-        entry
-      } = validResult;
-      if (cacheability && !cachedFieldData.cacheability) cachedFieldData.cacheability = cacheability;
-      if (entry) cachedFieldData.dataEntityData = entry;
+    if (result) {
+      fieldData = this._mergeObjects(result.entry, fieldData);
     }
+
+    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, {
@@ -867,59 +890,37 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     const {
       requestFieldPath: ancestorRequestFieldPath
     } = ancestorKeysAndPaths;
-
-    const keysAndPaths = CacheManager._getFieldKeysAndPaths(field, ancestorKeysAndPaths);
-
+    const keysAndPaths = buildFieldKeysAndPaths(field, ancestorKeysAndPaths, context);
     const {
       requestFieldPath,
       responseDataPath
     } = keysAndPaths;
 
-    const fieldData = _get(data, responseDataPath, null);
+    const fieldData = _get(data, responseDataPath);
 
-    if (!_isObjectLike(fieldData)) return;
-    const objectLikeFieldData = fieldData;
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+
+    if (!_isObjectLike(fieldData) && !(fieldTypeInfo !== null && fieldTypeInfo !== void 0 && fieldTypeInfo.hasDirectives)) {
+      return;
+    }
 
     this._setFieldTypeCacheDirective(cacheMetadata, {
       ancestorRequestFieldPath,
       requestFieldPath
     }, context);
 
-    iterateChildFields(field, objectLikeFieldData, (childField, _typeName, childIndex) => {
-      this._setFieldCacheability(childField, {
-        index: childIndex,
-        requestFieldPath,
-        responseDataPath
-      }, {
-        cacheMetadata,
-        data
-      }, options, context);
-    });
-  }
-
-  async _setFieldDataEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
-    cacheMetadata,
-    dataEntityData,
-    requestFieldPathData
-  }, options, context) {
-    const {
-      requestFieldPath
-    } = keysAndPaths;
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    const cacheability = cacheMetadata.get(requestFieldPath);
-    if (!fieldTypeInfo || !cacheability) return;
-    const promises = [];
-    promises.push(this._setRequestFieldPathCacheEntry(field, keysAndPaths, {
-      cacheability,
-      data: requestFieldPathData,
-      fieldTypeInfo
-    }, options, context));
-    promises.push(this._setDataEntityCacheEntry(keysAndPaths, {
-      cacheability,
-      data: dataEntityData,
-      fieldTypeInfo
-    }, options, context));
-    await Promise.all(promises);
+    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, {
@@ -929,7 +930,10 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     fieldTypeMap,
     operation
   }) {
-    if (cacheMetadata.has(requestFieldPath)) return;
+    if (cacheMetadata.has(requestFieldPath)) {
+      return;
+    }
+
     const fieldTypeInfo = fieldTypeMap.get(requestFieldPath);
 
     if (fieldTypeInfo && this._typeCacheDirectives[fieldTypeInfo.typeName]) {
@@ -966,24 +970,32 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     }, options, context);
   }
 
-  async _setRequestFieldPathCacheEntry(field, {
-    hashedRequestFieldCacheKey,
-    responseDataPath
-  }, {
+  async _setRequestFieldPathCacheEntry(field, keysAndPaths, {
     cacheability,
     data,
     fieldTypeInfo
   }, options, context) {
-    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
+    const {
+      hashedRequestFieldCacheKey,
+      responseDataPath
+    } = keysAndPaths;
 
-    let fieldData = _get(data, responseDataPath, null);
+    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) {
+        fieldData = filterOutPropsWithArgsOrDirectives(fieldData, field.selectionSet.selections, keysAndPaths, context);
+      }
+
       const result = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, context);
 
-      if (result) {
+      if (result && _isObjectLike(fieldData)) {
         fieldData = this._mergeObjects(result.entry, fieldData);
       }
 
@@ -1006,19 +1018,6 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     }
   }
 
-  async _setRequestFieldPathData(cachedFieldData, hash, options, context) {
-    const checkResult = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hash, options, context);
-
-    if (checkResult) {
-      const {
-        cacheability,
-        entry
-      } = checkResult;
-      if (cacheability) cachedFieldData.cacheability = cacheability;
-      if (entry) cachedFieldData.requestFieldPathData = entry;
-    }
-  }
-
 }, (_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 default function init(userOptions) {
   if (!_isPlainObject(userOptions)) {