@graphql-box/cache-manager 2.1.4 → 2.3.1

package/lib/main/main/index.js

@@ -24,19 +24,19 @@ var _isPlainObject2 = _interopRequireDefault(require("lodash/isPlainObject"));
 
 var _isObjectLike2 = _interopRequireDefault(require("lodash/isObjectLike"));
 
-var _isNumber2 = _interopRequireDefault(require("lodash/isNumber"));
-
 var _isArray2 = _interopRequireDefault(require("lodash/isArray"));
 
 var _get2 = _interopRequireDefault(require("lodash/get"));
 
 var _cloneDeep2 = _interopRequireDefault(require("lodash/cloneDeep"));
 
+var _assign2 = _interopRequireDefault(require("lodash/assign"));
+
 var _core = require("@graphql-box/core");
 
 var _helpers = require("@graphql-box/helpers");
 
-var _cacheability = _interopRequireDefault(require("cacheability"));
+var _cacheability2 = _interopRequireDefault(require("cacheability"));
 
 var _graphql = require("graphql");
 
@@ -44,8 +44,18 @@ var _consts = require("../consts");
 
 var _debug = require("../debug");
 
+var _buildKeysAndPaths = require("../helpers/buildKeysAndPaths");
+
 var _deriveOpCacheability = _interopRequireDefault(require("../helpers/deriveOpCacheability"));
 
+var _filterOutPropsWithArgsOrDirectives = _interopRequireDefault(require("../helpers/filterOutPropsWithArgsOrDirectives"));
+
+var _filterQuery = _interopRequireDefault(require("../helpers/filterQuery"));
+
+var _normalizeResponseData = _interopRequireDefault(require("../helpers/normalizeResponseData"));
+
+var _validTypeIDValue = require("../helpers/validTypeIDValue");
+
 var _dec, _dec2, _dec3, _class;
 
 let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCacheEntry)(), _dec3 = (0, _debug.logPartialCompiled)(), (_class = class CacheManager {
@@ -61,85 +71,11 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
       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 === null || dataEntityData === void 0 ? void 0 : dataEntityData.__typename) || (requestFieldPathData === null || requestFieldPathData === void 0 ? void 0 : 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 = `${(0, _isNumber2.default)(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) {
@@ -158,49 +94,25 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
   }
 
   static _getFieldDataFromAncestor(ancestorFieldData, propNameOrIndex) {
-    return (0, _isObjectLike2.default)(ancestorFieldData) ? ancestorFieldData[propNameOrIndex] : undefined;
-  }
-
-  static _getFieldKeysAndPaths(field, options) {
-    const {
-      index,
-      requestFieldCacheKey = "",
-      requestFieldPath = "",
-      responseDataPath = ""
-    } = options;
-    const name = (0, _helpers.getName)(field);
-
-    const updatedRequestFieldCacheKey = CacheManager._buildRequestFieldCacheKey(name, requestFieldCacheKey, (0, _helpers.getArguments)(field), (0, _helpers.getDirectives)(field), index);
-
-    const fieldAliasOrName = (0, _helpers.getAlias)(field) || name;
-    const updatedRequestFieldPath = (0, _isNumber2.default)(index) ? requestFieldPath : CacheManager._buildKey(fieldAliasOrName, requestFieldPath);
-    const propNameOrIndex = (0, _isNumber2.default)(index) ? index : fieldAliasOrName;
-
-    const updatedResponseDataPath = CacheManager._buildKey(propNameOrIndex, responseDataPath);
-
-    return {
-      hashedRequestFieldCacheKey: (0, _helpers.hashRequest)(updatedRequestFieldCacheKey),
-      propNameOrIndex,
-      requestFieldCacheKey: updatedRequestFieldCacheKey,
-      requestFieldPath: updatedRequestFieldPath,
-      responseDataPath: updatedResponseDataPath
-    };
+    return (0, _isObjectLike2.default)(ancestorFieldData) ? (0, _cloneDeep2.default)(ancestorFieldData[propNameOrIndex]) : undefined;
   }
 
   static _getOperationCacheControl(cacheMetadata, operation) {
     const defaultCacheControl = _consts.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;
-    return new Map([...partialQueryResponse.cacheMetadata, ...cacheMetadata]);
-  }
+  static _isNodeEntity(fieldTypeInfo) {
+    if (!fieldTypeInfo) {
+      return false;
+    }
 
-  static _isDataEntity(fieldTypeInfo) {
-    if (!fieldTypeInfo) return false;
     const {
       isEntity,
       possibleTypes
@@ -208,8 +120,8 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     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) {
@@ -217,6 +129,14 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     return !noCache && cacheability.checkTTL();
   }
 
+  static _mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse) {
+    if (!partialQueryResponse) {
+      return cacheMetadata;
+    }
+
+    return new Map([...partialQueryResponse.cacheMetadata, ...cacheMetadata]);
+  }
+
   static _setCachedData(requestData, {
     data
   }, propNameOrIndex) {
@@ -235,18 +155,21 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
   }, {
     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);
 
@@ -259,23 +182,39 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     data
   }, requestFieldPath, {
     dataTypeName,
-    fieldTypeName
+    fieldTypeName,
+    fragmentKind,
+    fragmentName
   }) {
-    if ((0, _isUndefined2.default)(fieldTypeName)) {
-      if (fieldPathChecklist.has(requestFieldPath)) return;
+    if ((0, _isUndefined2.default)(fieldTypeName) || fragmentKind === _helpers.FRAGMENT_SPREAD) {
+      if (fieldPathChecklist.has(requestFieldPath)) {
+        return;
+      }
+
       fieldPathChecklist.set(requestFieldPath, [{
+        fragmentKind,
+        fragmentName,
         hasData: !(0, _isUndefined2.default)(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: !(0, _isUndefined2.default)(data),
       typeName: dataTypeName
     }]);
@@ -316,23 +255,33 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
       return Promise.reject(new TypeError("@graphql-box/cache-manager expected an AST."));
     }
 
-    const cachedResponseData = await this._getCachedResponseData(requestData, options, context);
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: (0, _helpers.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,
@@ -344,14 +293,19 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     this._setPartialQueryResponse(hash, {
       cacheMetadata,
       data
-    }, options, context);
+    }, options, cacheManagerContext);
 
-    this._filterQuery(requestData, cachedResponseData, context);
-
-    const request = (0, _graphql.print)(ast);
+    const filteredAST = (0, _filterQuery.default)(requestData, cachedResponseData, cacheManagerContext);
+    const {
+      fragmentDefinitions,
+      typeIDKey,
+      ...rest
+    } = cacheManagerContext;
+    (0, _assign2.default)(context, rest);
+    const request = (0, _graphql.print)(filteredAST);
     return {
       updated: {
-        ast,
+        ast: filteredAST,
         hash: (0, _helpers.hashRequest)(request),
         request
       }
@@ -364,7 +318,11 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
 
   async checkQueryResponseCacheEntry(hash, options, context) {
     const result = await this._checkCacheEntry(_core.QUERY_RESPONSES, hash, options, context);
-    if (!result) return false;
+
+    if (!result) {
+      return false;
+    }
+
     const {
       cacheMetadata,
       data
@@ -380,101 +338,163 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
   }
 
   async resolveQuery(requestData, updatedRequestData, rawResponseData, options, context) {
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: (0, _helpers.getFragmentDefinitions)(updatedRequestData.ast),
+      typeIDKey: this._typeIDKey
+    };
     const dataCaching = [];
     const {
       cacheMetadata,
-      data
-    } = await this._resolveRequest(updatedRequestData, rawResponseData, options, context);
+      data,
+      hasNext,
+      path
+    } = await this._resolveRequest(updatedRequestData, rawResponseData, options, cacheManagerContext);
     let partialQueryResponse;
 
-    if (context.queryFiltered) {
-      dataCaching.push(this._setQueryResponseCacheEntry(updatedRequestData.hash, {
-        cacheMetadata,
-        data
-      }, options, context));
-      partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
+    if (cacheManagerContext.queryFiltered) {
+      if (!(rawResponseData.hasNext || rawResponseData.path)) {
+        dataCaching.push(this._setQueryResponseCacheEntry(updatedRequestData.hash, {
+          cacheMetadata,
+          data
+        }, options, cacheManagerContext));
+      }
+
+      if (!rawResponseData.path) {
+        partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
+      }
     }
 
-    const responseCacheMetadata = CacheManager._getResponseCacheMetadata(cacheMetadata, partialQueryResponse);
+    const responseCacheMetadata = CacheManager._mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse);
 
-    const responseData = this._getResponseData(data, partialQueryResponse);
+    const responseData = this._mergeResponseData(data, partialQueryResponse);
+
+    if (!(rawResponseData.hasNext || rawResponseData.path)) {
+      dataCaching.push(this._setQueryResponseCacheEntry(requestData.hash, {
+        cacheMetadata: responseCacheMetadata,
+        data: responseData
+      }, options, cacheManagerContext));
+    }
+
+    if (options.awaitDataCaching) {
+      await Promise.all(dataCaching);
+    }
 
-    dataCaching.push(this._setQueryResponseCacheEntry(requestData.hash, {
-      cacheMetadata: responseCacheMetadata,
-      data: responseData
-    }, options, context));
-    if (options.awaitDataCaching) await Promise.all(dataCaching);
     return {
       cacheMetadata: responseCacheMetadata,
-      data: responseData
+      data: responseData,
+      hasNext,
+      path
     };
   }
 
   async resolveRequest(requestData, rawResponseData, options, context) {
-    return this._resolveRequest(requestData, rawResponseData, options, context);
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: (0, _helpers.getFragmentDefinitions)(requestData.ast),
+      typeIDKey: this._typeIDKey
+    };
+    return this._resolveRequest(requestData, rawResponseData, options, cacheManagerContext);
   }
 
-  async _analyzeField(field, cachedAncestorFieldData, cachedResponseData, options, context) {
-    if ((0, _helpers.hasChildFields)(field)) {
-      await this._analyzeParentField(field, cachedAncestorFieldData, cachedResponseData, options, context);
+  async _analyzeFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
+    if ((0, _helpers.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 = (0, _buildKeysAndPaths.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 = (0, _buildKeysAndPaths.buildFieldKeysAndPaths)(fieldNode, cachedAncestorFieldData, context);
+    const {
+      propNameOrIndex,
+      requestFieldCacheKey,
+      requestFieldPath
+    } = keysAndPaths;
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
     const {
       cacheability,
-      dataEntityData,
+      data,
+      entityData,
       requestFieldPathData
-    } = cachedFieldData;
-    const data = !(0, _isUndefined2.default)(requestFieldPathData) || !(0, _isUndefined2.default)(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: (0, _get2.default)(data, _core.TYPE_NAME_KEY),
-      fieldTypeName: typeName
+      fieldTypeName: typeName,
+      fragmentKind,
+      fragmentName
     }, options, context);
 
-    if (!(0, _isObjectLike2.default)(data)) return;
+    if (!(0, _isObjectLike2.default)(data)) {
+      return;
+    }
+
     const objectLikeData = data;
     const promises = [];
-    (0, _helpers.iterateChildFields)(field, objectLikeData, (childField, childTypeName, childIndex) => {
-      promises.push(this._analyzeField(childField, {
+    (0, _helpers.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));
@@ -495,7 +515,11 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
 
     const queryNode = (0, _helpers.getOperationDefinitions)(ast, context.operation)[0];
     const fieldsAndTypeNames = (0, _helpers.getChildFields)(queryNode);
-    if (!fieldsAndTypeNames) return cacheMetadata;
+
+    if (!fieldsAndTypeNames) {
+      return cacheMetadata;
+    }
+
     fieldsAndTypeNames.forEach(({
       fieldNode
     }) => this._setFieldCacheability(fieldNode, {
@@ -510,9 +534,17 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
   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 ((0, _isUndefined2.default)(entry)) {
+        return false;
+      }
+
       return {
         cacheability,
         entry
@@ -543,148 +575,6 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     return cacheMetadata;
   }
 
-  _filterField(field, fieldPathChecklist, ancestorRequestFieldPath, context) {
-    const fieldsAndTypeNames = (0, _helpers.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 = (0, _helpers.getName)(childField);
-      if (childFieldName === this._typeIDKey || childFieldName === _core.TYPE_NAME_KEY) continue;
-
-      const {
-        requestFieldPath
-      } = CacheManager._getFieldKeysAndPaths(childField, {
-        requestFieldPath: ancestorRequestFieldPath
-      });
-
-      const {
-        hasData,
-        typeUnused
-      } = CacheManager._checkFieldPathChecklist(fieldPathChecklist.get(requestFieldPath), childTypeName);
-
-      if (hasData || typeUnused) {
-        if (!(0, _helpers.hasChildFields)(childField)) {
-          (0, _helpers.deleteChildFields)(field, childField);
-        } else if (this._filterField(childField, fieldPathChecklist, requestFieldPath, context)) {
-          (0, _helpers.deleteChildFields)(field, childField);
-        }
-      }
-    }
-
-    this._filterInlineFragments(field);
-
-    this._filterIDsAndTypeNames(field);
-
-    return !(0, _helpers.hasChildFields)(field);
-  }
-
-  _filterIDsAndTypeNames(field) {
-    const fieldsAndTypeNames = (0, _helpers.getChildFields)(field);
-    if (!fieldsAndTypeNames || fieldsAndTypeNames.length > 3) return false;
-    const fieldNames = fieldsAndTypeNames.map(({
-      fieldNode
-    }) => (0, _helpers.getName)(fieldNode));
-
-    if (fieldNames.length === 2 && fieldNames.every(name => name === this._typeIDKey || name === _core.TYPE_NAME_KEY)) {
-      (0, _helpers.deleteChildFields)(field, fieldsAndTypeNames.map(({
-        fieldNode
-      }) => fieldNode));
-      return true;
-    }
-
-    if (fieldNames.length === 1 && fieldNames[0] === this._typeIDKey || fieldNames[0] === _core.TYPE_NAME_KEY) {
-      const {
-        fieldNode
-      } = fieldsAndTypeNames[0];
-      (0, _helpers.deleteChildFields)(field, fieldNode);
-      return true;
-    }
-
-    return false;
-  }
-
-  _filterInlineFragments(field) {
-    const inlineFragments = (0, _helpers.getInlineFragments)(field);
-    let filtered = false;
-    inlineFragments.forEach(fragment => {
-      const fieldsAndTypeNames = (0, _helpers.getChildFields)(fragment);
-
-      if (!fieldsAndTypeNames || !fieldsAndTypeNames.length) {
-        (0, _helpers.deleteInlineFragments)(field, fragment);
-        filtered = true;
-        return;
-      }
-
-      if (fieldsAndTypeNames.length === 1) {
-        const {
-          fieldNode
-        } = fieldsAndTypeNames[0];
-
-        if ((0, _helpers.getName)(fieldNode) === this._typeIDKey) {
-          (0, _helpers.deleteInlineFragments)(field, fragment);
-          filtered = true;
-        }
-      }
-    });
-    return filtered;
-  }
-
-  _filterQuery({
-    ast
-  }, {
-    fieldPathChecklist
-  }, context) {
-    const queryNode = (0, _helpers.getOperationDefinitions)(ast, context.operation)[0];
-    const fieldsAndTypeNames = (0, _helpers.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)) {
-        (0, _helpers.deleteChildFields)(queryNode, fieldNode);
-      }
-    }
-
-    context.queryFiltered = true;
-  }
-
-  async _getCachedResponseData({
-    ast
-  }, options, context) {
-    const cachedResponseData = {
-      cacheMetadata: new Map(),
-      data: {},
-      fieldCount: {
-        missing: 0,
-        total: 0
-      },
-      fieldPathChecklist: new Map()
-    };
-    const queryNode = (0, _helpers.getOperationDefinitions)(ast, context.operation)[0];
-    const fieldsAndTypeNames = (0, _helpers.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;
-  }
-
   async _getCacheEntry(cacheType, hash, _options, _context) {
     try {
       return await this._cache.get(`${cacheType}::${hash}`);
@@ -701,11 +591,6 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     return partialQueryResponse;
   }
 
-  _getResponseData(responseData, partialQueryResponse) {
-    if (!partialQueryResponse) return responseData;
-    return this._mergeObjects(partialQueryResponse.data, responseData);
-  }
-
   async _hasCacheEntry(cacheType, hash) {
     try {
       return await this._cache.has(`${cacheType}::${hash}`);
@@ -718,9 +603,18 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     isEntity,
     possibleTypes
   }) {
-    if (!(0, _get2.default)(fieldData, this._typeIDKey, null)) return false;
-    if (isEntity) return true;
-    if (!possibleTypes.length) return false;
+    if (!(0, _get2.default)(fieldData, this._typeIDKey, null)) {
+      return false;
+    }
+
+    if (isEntity) {
+      return true;
+    }
+
+    if (!possibleTypes.length) {
+      return false;
+    }
+
     return possibleTypes.some(type => type.typeName === fieldData.__typename);
   }
 
@@ -730,126 +624,89 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     });
   }
 
-  async _parseFieldDataEntityAndRequestFieldPathCacheEntryData(field, ancestorKeysAndPaths, {
+  _mergeResponseData(responseData, partialQueryResponse) {
+    if (!partialQueryResponse) {
+      return responseData;
+    }
+
+    return this._mergeObjects(partialQueryResponse.data, responseData);
+  }
+
+  async _parseEntityAndRequestFieldPathCacheEntryData(field, ancestorKeysAndPaths, {
     cacheMetadata,
-    dataEntityData,
+    entityData,
     requestFieldPathData
   }, options, context) {
-    const keysAndPaths = CacheManager._getFieldKeysAndPaths(field, ancestorKeysAndPaths);
-
+    const keysAndPaths = (0, _buildKeysAndPaths.buildFieldKeysAndPaths)(field, ancestorKeysAndPaths, context);
     const {
       requestFieldCacheKey,
       requestFieldPath,
       responseDataPath
     } = keysAndPaths;
-    const fieldData = (0, _get2.default)(requestFieldPathData, responseDataPath, null);
-    if (!(0, _isObjectLike2.default)(fieldData)) return;
-    const objectLikeFieldData = fieldData;
-    const promises = [];
-    (0, _helpers.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 fieldData = (0, _get2.default)(requestFieldPathData, responseDataPath);
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+
+    if (!(0, _isObjectLike2.default)(fieldData) && !(fieldTypeInfo !== null && fieldTypeInfo !== void 0 && fieldTypeInfo.hasDirectives)) {
+      return;
+    }
+
+    if ((0, _isObjectLike2.default)(fieldData)) {
+      const promises = [];
+      (0, _helpers.iterateChildFields)(field, fieldData, context.fragmentDefinitions, (childField, _typeName, _fragmentKind, _fragmentName, childIndex) => {
+        promises.push(this._parseEntityAndRequestFieldPathCacheEntryData(childField, {
+          index: childIndex,
+          requestFieldCacheKey,
+          requestFieldPath,
+          responseDataPath
+        }, {
+          cacheMetadata,
+          entityData,
+          requestFieldPathData
+        }, options, context));
+      });
+      await Promise.all(promises);
+    }
+
+    await this._setEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
       cacheMetadata,
-      dataEntityData,
+      entityData,
       requestFieldPathData
     }, options, context);
   }
 
   async _resolveRequest(requestData, rawResponseData, options, context) {
+    const normalizedResponseData = rawResponseData.path ? (0, _normalizeResponseData.default)(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,
+      path
+    } = normalizedResponseData;
+    dataCaching.push(this._setEntityAndRequestFieldPathCacheEntries(requestData, {
       cacheMetadata,
-      dataEntityData: (0, _cloneDeep2.default)(data),
+      entityData: (0, _cloneDeep2.default)(data),
       requestFieldPathData: (0, _cloneDeep2.default)(data)
     }, options, context));
-    if (options.awaitDataCaching) await Promise.all(dataCaching);
-    return {
-      cacheMetadata,
-      data
-    };
-  }
-
-  async _setCacheEntry(cacheType, hash, value, cachemapOptions, _options, _context) {
-    try {
-      await this._cache.set(`${cacheType}::${hash}`, (0, _cloneDeep2.default)(value), cachemapOptions);
-    } catch (error) {}
-  }
 
-  async _setDataEntityAndRequestFieldPathCacheEntries(requestData, responseData, options, context) {
-    const operationNode = (0, _helpers.getOperationDefinitions)(requestData.ast, context.operation)[0];
-    const fieldsAndTypeNames = (0, _helpers.getChildFields)(operationNode);
-    if (!fieldsAndTypeNames) return;
-    await Promise.all(fieldsAndTypeNames.map(({
-      fieldNode
-    }) => {
-      return this._parseFieldDataEntityAndRequestFieldPathCacheEntryData(fieldNode, {
-        requestFieldPath: context.operation
-      }, responseData, options, context);
-    }));
-  }
-
-  async _setDataEntityCacheEntry({
-    responseDataPath
-  }, {
-    cacheability,
-    data,
-    fieldTypeInfo
-  }, options, context) {
-    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
-    let fieldData = (0, _get2.default)(data, responseDataPath, null);
-
-    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
-
-    if (!isEntity && hasArgsOrDirectives) {
-      (0, _unset2.default)(data, responseDataPath);
+    if (options.awaitDataCaching) {
+      await Promise.all(dataCaching);
     }
 
-    if (isEntity) {
-      const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
-      const entityDataKey = `${fieldTypeName}::${fieldData[this._typeIDKey]}`;
-      const result = await this._checkCacheEntry(_core.DATA_ENTITIES, entityDataKey, options, context);
-
-      if (result) {
-        fieldData = this._mergeObjects(result.entry, fieldData);
-      }
-
-      await this._setCacheEntry(_core.DATA_ENTITIES, entityDataKey, fieldData, {
-        cacheHeaders: {
-          cacheControl: cacheability.printCacheControl()
-        },
-        tag: options.tag
-      }, options, context);
-      (0, _set2.default)(data, responseDataPath, {
-        __cacheKey: `${_core.DATA_ENTITIES}::${entityDataKey}`
-      });
-    }
+    return {
+      cacheMetadata,
+      data,
+      hasNext,
+      path
+    };
   }
 
-  async _setDataEntityData(cachedFieldData, {
+  async _retrieveCachedEntityData(validTypeIDValue, {
     possibleTypes,
-    typeIDValue,
     typeName
   }, options, context) {
-    const requestFieldPathDataIDValue = (0, _isPlainObject2.default)(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(_core.DATA_ENTITIES, `${name}::${validTypeIDValue}`, options, context)));
     const validResults = checkResults.filter(result => !!result);
@@ -871,76 +728,228 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
       };
     }
 
-    if (validResult) {
+    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,
+        cacheability: entryCacheability,
         entry
-      } = validResult;
-      if (cacheability && !cachedFieldData.cacheability) cachedFieldData.cacheability = cacheability;
-      if (entry) cachedFieldData.dataEntityData = entry;
+      } = await this._retrieveCachedRequestFieldPathData(hashedRequestFieldCacheKey, options, context);
+
+      if (entry) {
+        requestFieldPathData = this._mergeObjects(requestFieldPathData, entry);
+      }
+
+      if (entryCacheability) {
+        cacheability = entryCacheability;
+      }
     }
+
+    const validTypeIDValue = (0, _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 = !(0, _isUndefined2.default)(requestFieldPathData) || !(0, _isUndefined2.default)(entityData) ? this._mergeObjects(requestFieldPathData, entityData) : (_entityData = entityData) !== null && _entityData !== void 0 ? _entityData : requestFieldPathData;
+    return {
+      cacheability,
+      data,
+      entityData,
+      requestFieldPathData
+    };
   }
 
-  _setFieldCacheability(field, ancestorKeysAndPaths, {
-    cacheMetadata,
-    data
+  async _retrieveCachedRequestFieldPathData(hash, options, context) {
+    return this._checkCacheEntry(_core.REQUEST_FIELD_PATHS, hash, options, context) || {};
+  }
+
+  async _retrieveCachedResponseData({
+    ast
   }, options, context) {
-    const {
-      requestFieldPath: ancestorRequestFieldPath
-    } = ancestorKeysAndPaths;
+    const cachedResponseData = {
+      cacheMetadata: new Map(),
+      data: {},
+      fieldCount: {
+        missing: 0,
+        total: 0
+      },
+      fieldPathChecklist: new Map()
+    };
+    const queryNode = (0, _helpers.getOperationDefinitions)(ast, context.operation)[0];
+    const fieldsAndTypeNames = (0, _helpers.getChildFields)(queryNode);
 
-    const keysAndPaths = CacheManager._getFieldKeysAndPaths(field, ancestorKeysAndPaths);
+    if (!fieldsAndTypeNames) {
+      return cachedResponseData;
+    }
 
-    const {
-      requestFieldPath,
-      responseDataPath
-    } = keysAndPaths;
-    const fieldData = (0, _get2.default)(data, responseDataPath, null);
-    if (!(0, _isObjectLike2.default)(fieldData)) return;
-    const objectLikeFieldData = fieldData;
+    await Promise.all(fieldsAndTypeNames.map(({
+      fieldNode
+    }) => this._analyzeFieldNode(fieldNode, {
+      requestFieldPath: context.operation
+    }, cachedResponseData, options, context)));
+    cachedResponseData.fieldCount = CacheManager._countFieldPathChecklist(cachedResponseData.fieldPathChecklist);
+    return cachedResponseData;
+  }
 
-    this._setFieldTypeCacheDirective(cacheMetadata, {
-      ancestorRequestFieldPath,
-      requestFieldPath
-    }, context);
+  async _setCacheEntry(cacheType, hash, value, cachemapOptions, _options, _context) {
+    try {
+      await this._cache.set(`${cacheType}::${hash}`, (0, _cloneDeep2.default)(value), cachemapOptions);
+    } catch (error) {}
+  }
 
-    (0, _helpers.iterateChildFields)(field, objectLikeFieldData, (childField, _typeName, childIndex) => {
-      this._setFieldCacheability(childField, {
-        index: childIndex,
-        requestFieldPath,
-        responseDataPath
-      }, {
-        cacheMetadata,
-        data
-      }, options, context);
-    });
+  async _setEntityAndRequestFieldPathCacheEntries(requestData, responseData, options, context) {
+    const operationNode = (0, _helpers.getOperationDefinitions)(requestData.ast, context.operation)[0];
+    const fieldsAndTypeNames = (0, _helpers.getChildFields)(operationNode);
+
+    if (!fieldsAndTypeNames) {
+      return;
+    }
+
+    await Promise.all(fieldsAndTypeNames.map(({
+      fieldNode
+    }) => {
+      return this._parseEntityAndRequestFieldPathCacheEntryData(fieldNode, {
+        requestFieldPath: context.operation
+      }, responseData, options, context);
+    }));
   }
 
-  async _setFieldDataEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
+  async _setEntityAndRequestFieldPathCacheEntry(field, keysAndPaths, {
     cacheMetadata,
-    dataEntityData,
+    entityData,
     requestFieldPathData
   }, options, context) {
     const {
-      requestFieldPath
+      requestFieldPath,
+      responseDataPath
     } = keysAndPaths;
+    const fieldData = (0, _get2.default)(entityData, responseDataPath);
     const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
     const cacheability = cacheMetadata.get(requestFieldPath);
-    if (!fieldTypeInfo || !cacheability) return;
+
+    if ((0, _isUndefined2.default)(fieldData) || !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));
+
+    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
+
+    if (!isEntity && fieldTypeInfo.hasArguments) {
+      (0, _unset2.default)(entityData, responseDataPath);
+    }
+
+    if (isEntity) {
+      promises.push(this._setEntityCacheEntry(keysAndPaths, {
+        cacheability,
+        data: entityData,
+        fieldTypeInfo
+      }, options, context));
+    }
+
     await Promise.all(promises);
   }
 
+  async _setEntityCacheEntry({
+    responseDataPath
+  }, {
+    cacheability,
+    data,
+    fieldTypeInfo
+  }, options, context) {
+    let fieldData = (0, _get2.default)(data, responseDataPath);
+    const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
+    const entityDataKey = `${fieldTypeName}::${fieldData[this._typeIDKey]}`;
+    const result = await this._checkCacheEntry(_core.DATA_ENTITIES, entityDataKey, options, context);
+
+    if (result) {
+      fieldData = this._mergeObjects(result.entry, fieldData);
+    }
+
+    await this._setCacheEntry(_core.DATA_ENTITIES, entityDataKey, fieldData, {
+      cacheHeaders: {
+        cacheControl: cacheability.printCacheControl()
+      },
+      tag: options.tag
+    }, options, context);
+    (0, _set2.default)(data, responseDataPath, {
+      __cacheKey: `${_core.DATA_ENTITIES}::${entityDataKey}`
+    });
+  }
+
+  _setFieldCacheability(field, ancestorKeysAndPaths, {
+    cacheMetadata,
+    data
+  }, options, context) {
+    const {
+      requestFieldPath: ancestorRequestFieldPath
+    } = ancestorKeysAndPaths;
+    const keysAndPaths = (0, _buildKeysAndPaths.buildFieldKeysAndPaths)(field, ancestorKeysAndPaths, context);
+    const {
+      requestFieldPath,
+      responseDataPath
+    } = keysAndPaths;
+    const fieldData = (0, _get2.default)(data, responseDataPath);
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+
+    if (!(0, _isObjectLike2.default)(fieldData) && !(fieldTypeInfo !== null && fieldTypeInfo !== void 0 && fieldTypeInfo.hasDirectives)) {
+      return;
+    }
+
+    this._setFieldTypeCacheDirective(cacheMetadata, {
+      ancestorRequestFieldPath,
+      requestFieldPath
+    }, context);
+
+    if ((0, _isObjectLike2.default)(fieldData)) {
+      (0, _helpers.iterateChildFields)(field, fieldData, context.fragmentDefinitions, (childField, _typeName, _fragmentKind, _fragmentName, childIndex) => {
+        this._setFieldCacheability(childField, {
+          index: childIndex,
+          requestFieldPath,
+          responseDataPath
+        }, {
+          cacheMetadata,
+          data
+        }, options, context);
+      });
+    }
+  }
+
   _setFieldTypeCacheDirective(cacheMetadata, {
     ancestorRequestFieldPath,
     requestFieldPath
@@ -948,11 +957,14 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     fieldTypeMap,
     operation
   }) {
-    if (cacheMetadata.has(requestFieldPath)) return;
+    if (cacheMetadata.has(requestFieldPath)) {
+      return;
+    }
+
     const fieldTypeInfo = fieldTypeMap.get(requestFieldPath);
 
     if (fieldTypeInfo && this._typeCacheDirectives[fieldTypeInfo.typeName]) {
-      const cacheability = new _cacheability.default({
+      const cacheability = new _cacheability2.default({
         cacheControl: this._typeCacheDirectives[fieldTypeInfo.typeName]
       });
 
@@ -985,23 +997,31 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     }, options, context);
   }
 
-  async _setRequestFieldPathCacheEntry(field, {
-    hashedRequestFieldCacheKey,
-    responseDataPath
-  }, {
+  async _setRequestFieldPathCacheEntry(field, keysAndPaths, {
     cacheability,
     data,
     fieldTypeInfo
   }, options, context) {
-    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
-    let fieldData = (0, _get2.default)(data, responseDataPath, null);
+    const {
+      hashedRequestFieldCacheKey,
+      responseDataPath
+    } = keysAndPaths;
+    let fieldData = (0, _get2.default)(data, responseDataPath);
 
     const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
 
+    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
+
     if (context.operation === _core.QUERY && (isEntity || hasArgsOrDirectives)) {
+      var _field$selectionSet;
+
+      if ((0, _isPlainObject2.default)(fieldData) && (_field$selectionSet = field.selectionSet) !== null && _field$selectionSet !== void 0 && _field$selectionSet.selections) {
+        fieldData = (0, _filterOutPropsWithArgsOrDirectives.default)(fieldData, field.selectionSet.selections, keysAndPaths, context);
+      }
+
       const result = await this._checkCacheEntry(_core.REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, context);
 
-      if (result) {
+      if (result && (0, _isObjectLike2.default)(fieldData)) {
         fieldData = this._mergeObjects(result.entry, fieldData);
       }
 
@@ -1024,19 +1044,6 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     }
   }
 
-  async _setRequestFieldPathData(cachedFieldData, hash, options, context) {
-    const checkResult = await this._checkCacheEntry(_core.REQUEST_FIELD_PATHS, hash, options, context);
-
-    if (checkResult) {
-      const {
-        cacheability,
-        entry
-      } = checkResult;
-      if (cacheability) cachedFieldData.cacheability = cacheability;
-      if (entry) cachedFieldData.requestFieldPathData = entry;
-    }
-  }
-
 }, ((0, _applyDecoratedDescriptor2.default)(_class.prototype, "_getCacheEntry", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "_getCacheEntry"), _class.prototype), (0, _applyDecoratedDescriptor2.default)(_class.prototype, "_setCacheEntry", [_dec2], Object.getOwnPropertyDescriptor(_class.prototype, "_setCacheEntry"), _class.prototype), (0, _applyDecoratedDescriptor2.default)(_class.prototype, "_setPartialQueryResponse", [_dec3], Object.getOwnPropertyDescriptor(_class.prototype, "_setPartialQueryResponse"), _class.prototype)), _class));
 exports.CacheManager = CacheManager;