@graphql-box/cache-manager 2.1.4 → 2.3.1

package/src/main/index.ts

@@ -17,15 +17,10 @@ import {
   TYPE_NAME_KEY,
 } from "@graphql-box/core";
 import {
+  FRAGMENT_SPREAD,
   dehydrateCacheMetadata,
-  deleteChildFields,
-  deleteInlineFragments,
-  getAlias,
-  getArguments,
   getChildFields,
-  getDirectives,
-  getInlineFragments,
-  getName,
+  getFragmentDefinitions,
   getOperationDefinitions,
   hasChildFields,
   hashRequest,
@@ -35,20 +30,19 @@ import {
 } from "@graphql-box/helpers";
 import Cacheability from "cacheability";
 import { FieldNode, print } from "graphql";
-import { cloneDeep, get, isArray, isNumber, isObjectLike, isPlainObject, isUndefined, set, unset } from "lodash";
+import { assign, cloneDeep, get, isArray, isObjectLike, isPlainObject, isUndefined, set, unset } from "lodash";
 import { CACHE_CONTROL, HEADER_NO_CACHE, METADATA, NO_CACHE } from "../consts";
 import { logCacheEntry, logCacheQuery, logPartialCompiled } from "../debug";
 import {
   AnalyzeQueryResult,
   AncestorKeysAndPaths,
+  CacheManagerContext,
   CacheManagerDef,
   CacheManagerInit,
   CachedAncestorFieldData,
-  CachedFieldData,
   CachedResponseData,
   CachemapOptions,
   CheckCacheEntryResult,
-  CheckFieldPathChecklistResult,
   ClientOptions,
   ConstructorOptions,
   DataForCachingEntry,
@@ -57,16 +51,20 @@ import {
   FieldPathChecklistValue,
   InitOptions,
   KeysAndPaths,
-  KeysAndPathsOptions,
   MergedCachedFieldData,
   PartialQueryResponse,
   PartialQueryResponses,
   QueryResponseCacheEntry,
   ResponseDataForCaching,
-  TypeNames,
+  TypeNamesAndKind,
   UserOptions,
 } from "../defs";
+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 class CacheManager implements CacheManagerDef {
   public static async init(options: InitOptions): Promise<CacheManager> {
@@ -81,73 +79,11 @@ export class CacheManager implements CacheManagerDef {
       errors.push(new TypeError(message));
     }
 
-    if (errors.length) return Promise.reject(errors);
-
-    return new CacheManager(options);
-  }
-
-  private static _analyzeLeafField(
-    field: FieldNode,
-    cachedAncestorFieldData: CachedAncestorFieldData,
-    { data, fieldPathChecklist }: CachedResponseData,
-    _options: RequestOptions,
-    _context: RequestContext,
-  ): void {
-    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);
-  }
-
-  private static _buildKey(key: string | number, path: string): string {
-    const paths: (string | number)[] = [];
-    if (path.length) paths.push(path);
-    paths.push(key);
-    return paths.join(".");
-  }
-
-  private static _buildRequestFieldCacheKey(
-    name: string,
-    requestFieldCacheKey: string,
-    args?: PlainObjectMap,
-    directives?: PlainObjectMap,
-    index?: number,
-  ): string {
-    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);
-  }
-
-  private static _checkFieldPathChecklist(
-    fieldPathChecklistValues: FieldPathChecklistValue[] | undefined,
-    fieldTypeName: string | undefined,
-  ): CheckFieldPathChecklistResult {
-    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);
   }
 
   private static _countFieldPathChecklist(fieldPathChecklist: FieldPathChecklist): FieldCount {
@@ -163,67 +99,33 @@ export class CacheManager implements CacheManagerDef {
   }
 
   private static _getFieldDataFromAncestor(ancestorFieldData: any, propNameOrIndex: string | number): any {
-    return isObjectLike(ancestorFieldData) ? ancestorFieldData[propNameOrIndex] : undefined;
-  }
-
-  private static _getFieldKeysAndPaths(field: FieldNode, options: KeysAndPathsOptions): KeysAndPaths {
-    const { index, requestFieldCacheKey = "", requestFieldPath = "", responseDataPath = "" } = options;
-    const name = getName(field) as string;
-
-    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;
   }
 
   private static _getOperationCacheControl(cacheMetadata: CacheMetadata | undefined, operation: string): string {
     const defaultCacheControl = HEADER_NO_CACHE;
-    if (!cacheMetadata) return defaultCacheControl;
+
+    if (!cacheMetadata) {
+      return defaultCacheControl;
+    }
 
     const cacheability = cacheMetadata.get(operation);
     return cacheability ? cacheability.printCacheControl() : defaultCacheControl;
   }
 
-  private static _getResponseCacheMetadata(
-    cacheMetadata: CacheMetadata,
-    partialQueryResponse?: PartialQueryResponse,
-  ): CacheMetadata {
-    if (!partialQueryResponse) return cacheMetadata;
-
-    return new Map([...partialQueryResponse.cacheMetadata, ...cacheMetadata]);
-  }
-
-  private static _isDataEntity(fieldTypeInfo?: FieldTypeInfo): boolean {
-    if (!fieldTypeInfo) return false;
+  private static _isNodeEntity(fieldTypeInfo?: FieldTypeInfo): boolean {
+    if (!fieldTypeInfo) {
+      return false;
+    }
 
     const { isEntity, possibleTypes } = fieldTypeInfo;
     return isEntity || possibleTypes.some(type => !!type.isEntity);
   }
 
-  private static _isRequestFieldPath(fieldTypeInfo?: FieldTypeInfo): boolean {
+  private static _isNodeRequestFieldPath(fieldTypeInfo?: FieldTypeInfo): boolean {
     return (
       !!fieldTypeInfo &&
-      (this._isDataEntity(fieldTypeInfo) || fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives)
+      (this._isNodeEntity(fieldTypeInfo) || fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives)
     );
   }
 
@@ -232,6 +134,17 @@ export class CacheManager implements CacheManagerDef {
     return !noCache && cacheability.checkTTL();
   }
 
+  private static _mergeResponseCacheMetadata(
+    cacheMetadata: CacheMetadata,
+    partialQueryResponse?: PartialQueryResponse,
+  ): CacheMetadata {
+    if (!partialQueryResponse) {
+      return cacheMetadata;
+    }
+
+    return new Map([...partialQueryResponse.cacheMetadata, ...cacheMetadata]);
+  }
+
   private static _setCachedData(
     requestData: PlainObjectMap,
     { data }: MergedCachedFieldData,
@@ -249,12 +162,12 @@ export class CacheManager implements CacheManagerDef {
     cachedFieldData: MergedCachedFieldData,
     { cacheMetadata, data, fieldPathChecklist }: CachedResponseData,
     { propNameOrIndex, requestFieldPath }: KeysAndPaths,
-    typeNames: TypeNames,
+    typeNamesAndKind: TypeNamesAndKind,
     _options: RequestOptions,
-    { operation }: RequestContext,
+    { operation }: CacheManagerContext,
   ) {
     CacheManager._setCacheMetadata(cacheMetadata, cachedFieldData.cacheability, requestFieldPath, operation);
-    CacheManager._setFieldPathChecklist(fieldPathChecklist, cachedFieldData, requestFieldPath, typeNames);
+    CacheManager._setFieldPathChecklist(fieldPathChecklist, cachedFieldData, requestFieldPath, typeNamesAndKind);
     CacheManager._setCachedData(data, cachedFieldData, propNameOrIndex);
   }
 
@@ -264,7 +177,9 @@ export class CacheManager implements CacheManagerDef {
     requestFieldPath: string,
     operation: string,
   ): void {
-    if (!cacheability) return;
+    if (!cacheability) {
+      return;
+    }
 
     cacheMetadata.set(requestFieldPath, cacheability);
     const operationCacheability = cacheMetadata.get(operation);
@@ -278,23 +193,31 @@ export class CacheManager implements CacheManagerDef {
     fieldPathChecklist: FieldPathChecklist,
     { data }: MergedCachedFieldData,
     requestFieldPath: string,
-    { dataTypeName, fieldTypeName }: TypeNames,
+    { dataTypeName, fieldTypeName, fragmentKind, fragmentName }: TypeNamesAndKind,
   ): void {
-    if (isUndefined(fieldTypeName)) {
-      if (fieldPathChecklist.has(requestFieldPath)) return;
-      fieldPathChecklist.set(requestFieldPath, [{ hasData: !isUndefined(data) }]);
+    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 as FieldPathChecklistValue[]) : [];
-    if (checklistValues.some(({ typeName }) => typeName === dataTypeName)) return;
+
+    if (checklistValues.some(({ typeName }) => typeName === dataTypeName)) {
+      return;
+    }
 
     fieldPathChecklist.set(requestFieldPath, [
       ...checklistValues,
-      { hasData: !isUndefined(data), typeName: dataTypeName as string },
+      { fragmentKind, fragmentName, hasData: !isUndefined(data), typeName: dataTypeName as string },
     ]);
   }
 
@@ -329,22 +252,35 @@ export class CacheManager implements CacheManagerDef {
       return Promise.reject(new TypeError("@graphql-box/cache-manager expected an AST."));
     }
 
-    const cachedResponseData = await this._getCachedResponseData(requestData, options, context);
+    const cacheManagerContext: 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);
-      if (options.awaitDataCaching) await dataCaching;
+      const dataCaching = this._setQueryResponseCacheEntry(hash, { cacheMetadata, data }, options, cacheManagerContext);
+
+      if (options.awaitDataCaching) {
+        await dataCaching;
+      }
 
       return { response: { cacheMetadata, data } };
     }
 
-    this._setPartialQueryResponse(hash, { cacheMetadata, data }, options, context);
-    this._filterQuery(requestData, cachedResponseData, context);
-    const request = print(ast);
-    return { updated: { ast, hash: hashRequest(request), request } };
+    this._setPartialQueryResponse(hash, { cacheMetadata, data }, options, cacheManagerContext);
+    const filteredAST = filterQuery(requestData, cachedResponseData, cacheManagerContext);
+    const { fragmentDefinitions, typeIDKey, ...rest } = cacheManagerContext;
+    assign(context, rest);
+    const request = print(filteredAST);
+    return { updated: { ast: filteredAST, hash: hashRequest(request), request } };
   }
 
   public async checkCacheEntry(
@@ -363,7 +299,9 @@ export class CacheManager implements CacheManagerDef {
   ): Promise<ResponseData | false> {
     const result = await this._checkCacheEntry(QUERY_RESPONSES, hash, options, context);
 
-    if (!result) return false;
+    if (!result) {
+      return false;
+    }
 
     const { cacheMetadata, data } = result.entry as QueryResponseCacheEntry;
 
@@ -384,34 +322,59 @@ export class CacheManager implements CacheManagerDef {
     options: RequestOptions,
     context: RequestContext,
   ): Promise<ResponseData> {
+    const cacheManagerContext: CacheManagerContext = {
+      ...context,
+      fragmentDefinitions: getFragmentDefinitions(updatedRequestData.ast),
+      typeIDKey: this._typeIDKey,
+    };
+
     const dataCaching: Promise<void>[] = [];
-    const { cacheMetadata, data } = await this._resolveRequest(updatedRequestData, rawResponseData, options, context);
+
+    const { cacheMetadata, data, hasNext, path } = await this._resolveRequest(
+      updatedRequestData,
+      rawResponseData,
+      options,
+      cacheManagerContext,
+    );
 
     let partialQueryResponse: PartialQueryResponse | undefined;
 
-    if (context.queryFiltered) {
-      dataCaching.push(
-        this._setQueryResponseCacheEntry(updatedRequestData.hash, { cacheMetadata, data }, options, context),
-      );
+    if (cacheManagerContext.queryFiltered) {
+      if (!(rawResponseData.hasNext || rawResponseData.path)) {
+        dataCaching.push(
+          this._setQueryResponseCacheEntry(
+            updatedRequestData.hash,
+            { cacheMetadata, data },
+            options,
+            cacheManagerContext,
+          ),
+        );
+      }
 
-      partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
+      if (!rawResponseData.path) {
+        partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
+      }
     }
 
-    const responseCacheMetadata = CacheManager._getResponseCacheMetadata(cacheMetadata, partialQueryResponse);
-    const responseData = this._getResponseData(data, partialQueryResponse);
+    const responseCacheMetadata = CacheManager._mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse);
+    const responseData = this._mergeResponseData(data, partialQueryResponse);
 
-    dataCaching.push(
-      this._setQueryResponseCacheEntry(
-        requestData.hash,
-        { cacheMetadata: responseCacheMetadata, data: responseData },
-        options,
-        context,
-      ),
-    );
+    if (!(rawResponseData.hasNext || rawResponseData.path)) {
+      dataCaching.push(
+        this._setQueryResponseCacheEntry(
+          requestData.hash,
+          { cacheMetadata: responseCacheMetadata, data: responseData },
+          options,
+          cacheManagerContext,
+        ),
+      );
+    }
 
-    if (options.awaitDataCaching) await Promise.all(dataCaching);
+    if (options.awaitDataCaching) {
+      await Promise.all(dataCaching);
+    }
 
-    return { cacheMetadata: responseCacheMetadata, data: responseData };
+    return { cacheMetadata: responseCacheMetadata, data: responseData, hasNext, path };
   }
 
   public async resolveRequest(
@@ -420,82 +383,141 @@ export class CacheManager implements CacheManagerDef {
     options: RequestOptions,
     context: RequestContext,
   ): Promise<ResponseData> {
-    return this._resolveRequest(requestData, rawResponseData, options, context);
+    const cacheManagerContext: CacheManagerContext = {
+      ...context,
+      fragmentDefinitions: getFragmentDefinitions(requestData.ast),
+      typeIDKey: this._typeIDKey,
+    };
+
+    return this._resolveRequest(requestData, rawResponseData, options, cacheManagerContext);
   }
 
-  private async _analyzeField(
-    field: FieldNode,
+  private async _analyzeFieldNode(
+    fieldNode: FieldNode,
     cachedAncestorFieldData: CachedAncestorFieldData,
     cachedResponseData: CachedResponseData,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): Promise<void> {
-    if (hasChildFields(field)) {
-      await this._analyzeParentField(field, 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);
     }
   }
 
-  private async _analyzeParentField(
-    field: FieldNode,
+  private async _analyzeLeafFieldNode(
+    fieldNode: FieldNode,
     cachedAncestorFieldData: CachedAncestorFieldData,
     cachedResponseData: CachedResponseData,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): Promise<void> {
-    const keysAndPaths = CacheManager._getFieldKeysAndPaths(field, cachedAncestorFieldData);
-    const { hashedRequestFieldCacheKey, propNameOrIndex, requestFieldCacheKey, requestFieldPath } = keysAndPaths;
+    const keysAndPaths = buildFieldKeysAndPaths(fieldNode, cachedAncestorFieldData, context);
+    const { hashedRequestFieldCacheKey, propNameOrIndex, requestFieldPath } = keysAndPaths;
     const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+    const { entityData, fragmentKind, fragmentName, requestFieldPathData, typeName } = cachedAncestorFieldData;
 
-    const {
-      dataEntityData: ancestorDataEntityData,
-      requestFieldPathData: ancestorRequestFieldPathData,
-      typeName,
-    } = cachedAncestorFieldData;
-
-    const cachedFieldData: CachedFieldData = {
-      dataEntityData: CacheManager._getFieldDataFromAncestor(ancestorDataEntityData, propNameOrIndex),
-      requestFieldPathData: CacheManager._getFieldDataFromAncestor(ancestorRequestFieldPathData, propNameOrIndex),
+    const typeNamesAndKind = {
+      dataTypeName: entityData?.__typename || 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,
+      );
+
+      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,
+      );
 
-    if (CacheManager._isDataEntity(fieldTypeInfo)) {
-      await this._setDataEntityData(cachedFieldData, fieldTypeInfo as FieldTypeInfo, options, context);
+      CacheManager._setCachedData(cachedResponseData.data, { data: cachedFieldData }, propNameOrIndex);
     }
+  }
+
+  private async _analyzeParentFieldNode(
+    fieldNode: FieldNode,
+    cachedAncestorFieldData: CachedAncestorFieldData,
+    cachedResponseData: CachedResponseData,
+    options: RequestOptions,
+    context: CacheManagerContext,
+  ): Promise<void> {
+    const keysAndPaths = buildFieldKeysAndPaths(fieldNode, cachedAncestorFieldData, context);
+    const { propNameOrIndex, requestFieldCacheKey, requestFieldPath } = keysAndPaths;
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath) as FieldTypeInfo;
 
-    const { cacheability, dataEntityData, requestFieldPathData } = cachedFieldData;
+    const { cacheability, data, entityData, requestFieldPathData } = await this._retrieveCachedParentNodeData(
+      cachedAncestorFieldData,
+      keysAndPaths,
+      fieldTypeInfo,
+      options,
+      context,
+    );
 
-    const data =
-      !isUndefined(requestFieldPathData) || !isUndefined(dataEntityData)
-        ? this._mergeObjects(requestFieldPathData, dataEntityData)
-        : undefined;
+    const { fragmentKind, fragmentName, typeName } = cachedAncestorFieldData;
 
     CacheManager._setCachedResponseData(
       { cacheability, data },
       cachedResponseData,
       keysAndPaths,
-      { dataTypeName: get(data, TYPE_NAME_KEY), fieldTypeName: typeName },
+      { dataTypeName: get(data, TYPE_NAME_KEY), fieldTypeName: typeName, fragmentKind, fragmentName },
       options,
       context,
     );
 
-    if (!isObjectLike(data)) return;
+    if (!isObjectLike(data)) {
+      return;
+    }
 
     const objectLikeData = data as PlainObjectMap | any[];
     const promises: Promise<void>[] = [];
 
     iterateChildFields(
-      field,
+      fieldNode,
       objectLikeData,
-      (childField: FieldNode, childTypeName: string | undefined, childIndex?: number) => {
+      context.fragmentDefinitions,
+      (
+        childField: FieldNode,
+        childTypeName: string | undefined,
+        childFragmentKind: string | undefined,
+        childFragmentName: string | undefined,
+        childIndex?: number,
+      ) => {
         promises.push(
-          this._analyzeField(
+          this._analyzeFieldNode(
             childField,
-            { index: childIndex, requestFieldCacheKey, requestFieldPath, typeName: childTypeName, ...cachedFieldData },
+            {
+              cacheability,
+              entityData,
+              fragmentKind: childFragmentKind,
+              fragmentName: childFragmentName,
+              index: childIndex,
+              requestFieldCacheKey,
+              requestFieldPath,
+              requestFieldPathData,
+              typeName: childTypeName,
+            },
             { ...cachedResponseData, data: cachedResponseData.data[propNameOrIndex] },
             options,
             context,
@@ -511,12 +533,15 @@ export class CacheManager implements CacheManagerDef {
     { ast }: RequestData,
     { data, ...otherProps }: RawResponseDataWithMaybeCacheMetadata,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): CacheMetadata {
     const cacheMetadata = this._createCacheMetadata({ data, ...otherProps }, context);
     const queryNode = getOperationDefinitions(ast, context.operation)[0];
     const fieldsAndTypeNames = getChildFields(queryNode);
-    if (!fieldsAndTypeNames) return cacheMetadata;
+
+    if (!fieldsAndTypeNames) {
+      return cacheMetadata;
+    }
 
     fieldsAndTypeNames.forEach(({ fieldNode }) =>
       this._setFieldCacheability(
@@ -535,16 +560,20 @@ export class CacheManager implements CacheManagerDef {
     cacheType: CacheTypes,
     hash: string,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): Promise<CheckCacheEntryResult | false> {
     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 };
     } catch (error) {
@@ -554,7 +583,7 @@ export class CacheManager implements CacheManagerDef {
 
   private _createCacheMetadata(
     { _cacheMetadata, headers }: RawResponseDataWithMaybeCacheMetadata,
-    { operation }: RequestContext,
+    { operation }: CacheManagerContext,
   ): CacheMetadata {
     const cacheMetadata = new Map();
 
@@ -573,151 +602,13 @@ export class CacheManager implements CacheManagerDef {
     return cacheMetadata;
   }
 
-  private _filterField(
-    field: FieldNode,
-    fieldPathChecklist: FieldPathChecklist,
-    ancestorRequestFieldPath: string,
-    context: RequestContext,
-  ): boolean {
-    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);
-  }
-
-  private _filterIDsAndTypeNames(field: FieldNode): boolean {
-    const fieldsAndTypeNames = getChildFields(field);
-    if (!fieldsAndTypeNames || fieldsAndTypeNames.length > 3) return false;
-
-    const fieldNames = fieldsAndTypeNames.map(({ fieldNode }) => getName(fieldNode) as string);
-
-    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;
-  }
-
-  private _filterInlineFragments(field: FieldNode): boolean {
-    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;
-  }
-
-  private _filterQuery(
-    { ast }: RequestData,
-    { fieldPathChecklist }: CachedResponseData,
-    context: RequestContext,
-  ): void {
-    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);
-      }
-    }
-
-    context.queryFiltered = true;
-  }
-
-  private async _getCachedResponseData(
-    { ast }: RequestData,
-    options: RequestOptions,
-    context: RequestContext,
-  ): Promise<CachedResponseData> {
-    const cachedResponseData: 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;
-  }
-
   @logCacheQuery()
   private async _getCacheEntry(
     cacheType: CacheTypes,
     hash: string,
     _options: RequestOptions,
-    _context: RequestContext,
-  ): Promise<ResponseData> {
+    _context: CacheManagerContext,
+  ): Promise<any> {
     try {
       return await this._cache.get(`${cacheType}::${hash}`);
     } catch (errors) {
@@ -731,12 +622,6 @@ export class CacheManager implements CacheManagerDef {
     return partialQueryResponse;
   }
 
-  private _getResponseData(responseData: PlainObjectMap, partialQueryResponse?: PartialQueryResponse): PlainObjectMap {
-    if (!partialQueryResponse) return responseData;
-
-    return this._mergeObjects(partialQueryResponse.data, responseData);
-  }
-
   private async _hasCacheEntry(cacheType: CacheTypes, hash: string): Promise<Cacheability | false> {
     try {
       return await this._cache.has(`${cacheType}::${hash}`);
@@ -746,9 +631,18 @@ export class CacheManager implements CacheManagerDef {
   }
 
   private _isFieldEntity(fieldData: any, { isEntity, possibleTypes }: FieldTypeInfo): boolean {
-    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);
   }
 
@@ -758,43 +652,66 @@ export class CacheManager implements CacheManagerDef {
     });
   }
 
-  private async _parseFieldDataEntityAndRequestFieldPathCacheEntryData(
+  private _mergeResponseData(
+    responseData: PlainObjectMap,
+    partialQueryResponse?: PartialQueryResponse,
+  ): PlainObjectMap {
+    if (!partialQueryResponse) {
+      return responseData;
+    }
+
+    return this._mergeObjects(partialQueryResponse.data, responseData);
+  }
+
+  private async _parseEntityAndRequestFieldPathCacheEntryData(
     field: FieldNode,
     ancestorKeysAndPaths: AncestorKeysAndPaths,
-    { cacheMetadata, dataEntityData, requestFieldPathData }: ResponseDataForCaching,
+    { cacheMetadata, entityData, requestFieldPathData }: ResponseDataForCaching,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): Promise<void> {
-    const keysAndPaths = CacheManager._getFieldKeysAndPaths(field, ancestorKeysAndPaths);
+    const keysAndPaths = buildFieldKeysAndPaths(field, ancestorKeysAndPaths, context);
     const { requestFieldCacheKey, requestFieldPath, responseDataPath } = keysAndPaths;
-    const fieldData = get(requestFieldPathData, responseDataPath, null);
-    if (!isObjectLike(fieldData)) return;
+    const fieldData = get(requestFieldPathData, responseDataPath);
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
 
-    const objectLikeFieldData = fieldData as PlainObjectMap | any[];
-    const promises: Promise<void>[] = [];
+    if (!isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
+      return;
+    }
 
-    iterateChildFields(
-      field,
-      objectLikeFieldData,
-      (childField: FieldNode, _typeName: string | undefined, childIndex?: number) => {
-        promises.push(
-          this._parseFieldDataEntityAndRequestFieldPathCacheEntryData(
-            childField,
-            { index: childIndex, requestFieldCacheKey, requestFieldPath, responseDataPath },
-            { cacheMetadata, dataEntityData, requestFieldPathData },
-            options,
-            context,
-          ),
-        );
-      },
-    );
+    if (isObjectLike(fieldData)) {
+      const promises: Promise<void>[] = [];
 
-    await Promise.all(promises);
+      iterateChildFields(
+        field,
+        fieldData as PlainObjectMap | any[],
+        context.fragmentDefinitions,
+        (
+          childField: FieldNode,
+          _typeName: string | undefined,
+          _fragmentKind: string | undefined,
+          _fragmentName: string | undefined,
+          childIndex?: number,
+        ) => {
+          promises.push(
+            this._parseEntityAndRequestFieldPathCacheEntryData(
+              childField,
+              { index: childIndex, requestFieldCacheKey, requestFieldPath, responseDataPath },
+              { cacheMetadata, entityData, requestFieldPathData },
+              options,
+              context,
+            ),
+          );
+        },
+      );
+
+      await Promise.all(promises);
+    }
 
-    await this._setFieldDataEntityAndRequestFieldPathCacheEntry(
+    await this._setEntityAndRequestFieldPathCacheEntry(
       field,
       keysAndPaths,
-      { cacheMetadata, dataEntityData, requestFieldPathData },
+      { cacheMetadata, entityData, requestFieldPathData },
       options,
       context,
     );
@@ -804,24 +721,158 @@ export class CacheManager implements CacheManagerDef {
     requestData: RequestData,
     rawResponseData: RawResponseDataWithMaybeCacheMetadata,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): Promise<ResponseData> {
+    const normalizedResponseData = rawResponseData.path ? normalizeResponseData(rawResponseData) : rawResponseData;
     const dataCaching: Promise<void>[] = [];
-    const cacheMetadata = this._buildCacheMetadata(requestData, rawResponseData, options, context);
-    const { data } = rawResponseData;
+    const cacheMetadata = this._buildCacheMetadata(requestData, normalizedResponseData, options, context);
+    const { data, hasNext, path } = normalizedResponseData;
 
     dataCaching.push(
-      this._setDataEntityAndRequestFieldPathCacheEntries(
+      this._setEntityAndRequestFieldPathCacheEntries(
         requestData,
-        { cacheMetadata, dataEntityData: cloneDeep(data), requestFieldPathData: cloneDeep(data) },
+        { cacheMetadata, 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, hasNext, path };
+  }
+
+  private async _retrieveCachedEntityData(
+    validTypeIDValue: string | number,
+    { possibleTypes, typeName }: FieldTypeInfo,
+    options: RequestOptions,
+    context: CacheManagerContext,
+  ) {
+    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) as CheckCacheEntryResult[];
+    let validResult: CheckCacheEntryResult | undefined;
+
+    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 || {}) as Partial<CheckCacheEntryResult>;
+  }
+
+  private async _retrieveCachedParentNodeData(
+    { entityData: ancestorEntityData, requestFieldPathData: ancestorRequestFieldPathData }: CachedAncestorFieldData,
+    { hashedRequestFieldCacheKey, propNameOrIndex }: KeysAndPaths,
+    fieldTypeInfo: FieldTypeInfo,
+    options: RequestOptions,
+    context: CacheManagerContext,
+  ) {
+    let entityData = CacheManager._getFieldDataFromAncestor(ancestorEntityData, propNameOrIndex);
+    let requestFieldPathData = CacheManager._getFieldDataFromAncestor(ancestorRequestFieldPathData, propNameOrIndex);
+    let cacheability: Cacheability | undefined;
+
+    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) {
+      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?.metadata.ttl)) {
+        cacheability = entryCacheability;
+      }
+    }
+
+    const data =
+      !isUndefined(requestFieldPathData) || !isUndefined(entityData)
+        ? this._mergeObjects(requestFieldPathData, entityData)
+        : entityData ?? requestFieldPathData;
+
+    return {
+      cacheability,
+      data,
+      entityData,
+      requestFieldPathData,
+    };
+  }
 
-    return { cacheMetadata, data };
+  private async _retrieveCachedRequestFieldPathData(
+    hash: string,
+    options: RequestOptions,
+    context: CacheManagerContext,
+  ) {
+    return (this._checkCacheEntry(REQUEST_FIELD_PATHS, hash, options, context) || {}) as Partial<CheckCacheEntryResult>;
+  }
+
+  private async _retrieveCachedResponseData(
+    { ast }: RequestData,
+    options: RequestOptions,
+    context: CacheManagerContext,
+  ): Promise<CachedResponseData> {
+    const cachedResponseData: 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;
   }
 
   @logCacheEntry()
@@ -831,7 +882,7 @@ export class CacheManager implements CacheManagerDef {
     value: any,
     cachemapOptions: CachemapOptions,
     _options: RequestOptions,
-    _context: RequestContext,
+    _context: CacheManagerContext,
   ): Promise<void> {
     try {
       await this._cache.set(`${cacheType}::${hash}`, cloneDeep(value), cachemapOptions);
@@ -840,19 +891,22 @@ export class CacheManager implements CacheManagerDef {
     }
   }
 
-  private async _setDataEntityAndRequestFieldPathCacheEntries(
+  private async _setEntityAndRequestFieldPathCacheEntries(
     requestData: RequestData,
     responseData: ResponseDataForCaching,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): Promise<void> {
     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(
+        return this._parseEntityAndRequestFieldPathCacheEntryData(
           fieldNode,
           { requestFieldPath: context.operation },
           responseData,
@@ -863,80 +917,74 @@ export class CacheManager implements CacheManagerDef {
     );
   }
 
-  private async _setDataEntityCacheEntry(
-    { responseDataPath }: KeysAndPaths,
-    { cacheability, data, fieldTypeInfo }: DataForCachingEntry,
+  private async _setEntityAndRequestFieldPathCacheEntry(
+    field: FieldNode,
+    keysAndPaths: KeysAndPaths,
+    { cacheMetadata, entityData, requestFieldPathData }: ResponseDataForCaching,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ) {
-    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
-    let fieldData = get(data, responseDataPath, null);
-    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
+    const { requestFieldPath, responseDataPath } = keysAndPaths;
+    const fieldData = get(entityData, responseDataPath);
+    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);
-
-      if (result) {
-        fieldData = this._mergeObjects(result.entry, fieldData);
-      }
+    const promises: Promise<void>[] = [];
 
-      await this._setCacheEntry(
-        DATA_ENTITIES,
-        entityDataKey,
-        fieldData,
-        { cacheHeaders: { cacheControl: cacheability.printCacheControl() }, tag: options.tag },
+    promises.push(
+      this._setRequestFieldPathCacheEntry(
+        field,
+        keysAndPaths,
+        { cacheability, data: requestFieldPathData, fieldTypeInfo },
         options,
         context,
-      );
+      ),
+    );
+
+    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
 
-      set(data, responseDataPath, { __cacheKey: `${DATA_ENTITIES}::${entityDataKey}` });
+    if (!isEntity && fieldTypeInfo.hasArguments) {
+      unset(entityData, responseDataPath);
     }
+
+    if (isEntity) {
+      promises.push(
+        this._setEntityCacheEntry(keysAndPaths, { cacheability, data: entityData, fieldTypeInfo }, options, context),
+      );
+    }
+
+    await Promise.all(promises);
   }
 
-  private async _setDataEntityData(
-    cachedFieldData: CachedFieldData,
-    { possibleTypes, typeIDValue, typeName }: FieldTypeInfo,
+  private async _setEntityCacheEntry(
+    { responseDataPath }: KeysAndPaths,
+    { cacheability, data, fieldTypeInfo }: DataForCachingEntry,
     options: RequestOptions,
-    context: RequestContext,
-  ): Promise<void> {
-    const requestFieldPathDataIDValue = isPlainObject(cachedFieldData.requestFieldPathData)
-      ? cachedFieldData.requestFieldPathData[this._typeIDKey]
-      : undefined;
-
-    const validTypeIDValue = typeIDValue || requestFieldPathDataIDValue;
-    if (!validTypeIDValue) return;
+    context: CacheManagerContext,
+  ) {
+    let fieldData = get(data, responseDataPath);
+    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 typeNames = [...possibleTypes.map(type => type.typeName), typeName];
+    if (result) {
+      fieldData = this._mergeObjects(result.entry, fieldData);
+    }
 
-    const checkResults = await Promise.all(
-      typeNames.map(name => this._checkCacheEntry(DATA_ENTITIES, `${name}::${validTypeIDValue}`, options, context)),
+    await this._setCacheEntry(
+      DATA_ENTITIES,
+      entityDataKey,
+      fieldData,
+      { cacheHeaders: { cacheControl: cacheability.printCacheControl() }, tag: options.tag },
+      options,
+      context,
     );
 
-    const validResults = checkResults.filter(result => !!result) as CheckCacheEntryResult[];
-    let validResult: CheckCacheEntryResult | undefined;
-
-    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), {}),
-      };
-    }
-
-    if (validResult) {
-      const { cacheability, entry } = validResult;
-      if (cacheability && !cachedFieldData.cacheability) cachedFieldData.cacheability = cacheability;
-      if (entry) cachedFieldData.dataEntityData = entry;
-    }
+    set(data, responseDataPath, { __cacheKey: `${DATA_ENTITIES}::${entityDataKey}` });
   }
 
   private _setFieldCacheability(
@@ -944,74 +992,52 @@ export class CacheManager implements CacheManagerDef {
     ancestorKeysAndPaths: AncestorKeysAndPaths,
     { cacheMetadata, data }: ResponseData,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): void {
     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);
-    if (!isObjectLike(fieldData)) return;
-
-    const objectLikeFieldData = fieldData as PlainObjectMap | any[];
-    this._setFieldTypeCacheDirective(cacheMetadata, { ancestorRequestFieldPath, requestFieldPath }, context);
-
-    iterateChildFields(
-      field,
-      objectLikeFieldData,
-      (childField: FieldNode, _typeName: string | undefined, childIndex?: number) => {
-        this._setFieldCacheability(
-          childField,
-          { index: childIndex, requestFieldPath, responseDataPath },
-          { cacheMetadata, data },
-          options,
-          context,
-        );
-      },
-    );
-  }
-
-  private async _setFieldDataEntityAndRequestFieldPathCacheEntry(
-    field: FieldNode,
-    keysAndPaths: KeysAndPaths,
-    { cacheMetadata, dataEntityData, requestFieldPathData }: ResponseDataForCaching,
-    options: RequestOptions,
-    context: RequestContext,
-  ) {
-    const { requestFieldPath } = keysAndPaths;
+    const fieldData = get(data, responseDataPath);
     const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    const cacheability = cacheMetadata.get(requestFieldPath);
-    if (!fieldTypeInfo || !cacheability) return;
 
-    const promises: Promise<void>[] = [];
-
-    promises.push(
-      this._setRequestFieldPathCacheEntry(
-        field,
-        keysAndPaths,
-        { cacheability, data: requestFieldPathData, fieldTypeInfo },
-        options,
-        context,
-      ),
-    );
+    if (!isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
+      return;
+    }
 
-    promises.push(
-      this._setDataEntityCacheEntry(
-        keysAndPaths,
-        { cacheability, data: dataEntityData, fieldTypeInfo },
-        options,
-        context,
-      ),
-    );
+    this._setFieldTypeCacheDirective(cacheMetadata, { ancestorRequestFieldPath, requestFieldPath }, context);
 
-    await Promise.all(promises);
+    if (isObjectLike(fieldData)) {
+      iterateChildFields(
+        field,
+        fieldData as PlainObjectMap | any[],
+        context.fragmentDefinitions,
+        (
+          childField: FieldNode,
+          _typeName: string | undefined,
+          _fragmentKind: string | undefined,
+          _fragmentName: string | undefined,
+          childIndex?: number,
+        ) => {
+          this._setFieldCacheability(
+            childField,
+            { index: childIndex, requestFieldPath, responseDataPath },
+            { cacheMetadata, data },
+            options,
+            context,
+          );
+        },
+      );
+    }
   }
 
   private _setFieldTypeCacheDirective(
     cacheMetadata: CacheMetadata,
     { ancestorRequestFieldPath, requestFieldPath }: { ancestorRequestFieldPath?: string; requestFieldPath: string },
-    { fieldTypeMap, operation }: RequestContext,
+    { fieldTypeMap, operation }: CacheManagerContext,
   ): void {
-    if (cacheMetadata.has(requestFieldPath)) return;
+    if (cacheMetadata.has(requestFieldPath)) {
+      return;
+    }
 
     const fieldTypeInfo = fieldTypeMap.get(requestFieldPath);
 
@@ -1033,7 +1059,7 @@ export class CacheManager implements CacheManagerDef {
     hash: string,
     partialQueryResponse: PartialQueryResponse,
     _options: RequestOptions,
-    _context: RequestContext,
+    _context: CacheManagerContext,
   ): Promise<void> {
     this._partialQueryResponses.set(hash, partialQueryResponse);
   }
@@ -1042,7 +1068,7 @@ export class CacheManager implements CacheManagerDef {
     hash: string,
     { cacheMetadata, data }: ResponseData,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): Promise<void> {
     const dehydratedCacheMetadata = dehydrateCacheMetadata(cacheMetadata);
     const cacheControl = CacheManager._getOperationCacheControl(cacheMetadata, context.operation);
@@ -1059,19 +1085,24 @@ export class CacheManager implements CacheManagerDef {
 
   private async _setRequestFieldPathCacheEntry(
     field: FieldNode,
-    { hashedRequestFieldCacheKey, responseDataPath }: KeysAndPaths,
+    keysAndPaths: KeysAndPaths,
     { cacheability, data, fieldTypeInfo }: DataForCachingEntry,
     options: RequestOptions,
-    context: RequestContext,
+    context: CacheManagerContext,
   ): Promise<void> {
-    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
-    let fieldData = get(data, responseDataPath, null);
+    const { hashedRequestFieldCacheKey, responseDataPath } = keysAndPaths;
+    let fieldData = get(data, responseDataPath);
     const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
+    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
 
     if (context.operation === QUERY && (isEntity || hasArgsOrDirectives)) {
+      if (isPlainObject(fieldData) && field.selectionSet?.selections) {
+        fieldData = filterOutPropsWithArgsOrDirectives(fieldData, field.selectionSet.selections, keysAndPaths, context);
+      }
+
       const result = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, context);
 
-      if (result) {
+      if (result && isObjectLike(fieldData)) {
         fieldData = this._mergeObjects(result.entry, fieldData);
       }
 
@@ -1093,21 +1124,6 @@ export class CacheManager implements CacheManagerDef {
       }
     }
   }
-
-  private async _setRequestFieldPathData(
-    cachedFieldData: CachedFieldData,
-    hash: string,
-    options: RequestOptions,
-    context: RequestContext,
-  ): Promise<void> {
-    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;
-    }
-  }
 }
 
 export default function init(userOptions: UserOptions): CacheManagerInit {