@graphql-box/cache-manager 2.4.0 → 2.5.0

package/src/main/index.ts

@@ -63,7 +63,11 @@ 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 isLastResponseChunk from "../helpers/isLastResponseChunk";
+import isNotLastResponseChunk from "../helpers/isNotLastResponseChunk";
+import isNotResponseChunk from "../helpers/isNotResponseChunk";
+import mergeResponseDataSets from "../helpers/mergeResponseDataSets";
+import normalizePatchResponseData from "../helpers/normalizePatchResponseData";
 import { getValidTypeIDValue } from "../helpers/validTypeIDValue";
 
 export class CacheManager implements CacheManagerDef {
@@ -225,6 +229,7 @@ export class CacheManager implements CacheManagerDef {
   private _cascadeCacheControl: boolean;
   private _fallbackOperationCacheability: string;
   private _partialQueryResponses: PartialQueryResponses = new Map();
+  private _responseChunksAwaitingCaching: Map<string, RawResponseDataWithMaybeCacheMetadata[]> = new Map();
   private _typeCacheDirectives: PlainObjectStringMap;
   private _typeIDKey: string;
 
@@ -283,6 +288,37 @@ export class CacheManager implements CacheManagerDef {
     return { updated: { ast: filteredAST, hash: hashRequest(request), request } };
   }
 
+  public async cacheQuery(
+    requestData: RequestData,
+    updatedRequestData: RequestData,
+    rawResponseData: RawResponseDataWithMaybeCacheMetadata,
+    options: RequestOptions,
+    context: RequestContext,
+  ): Promise<ResponseData> {
+    const cacheManagerContext: CacheManagerContext = {
+      ...context,
+      fragmentDefinitions: getFragmentDefinitions(updatedRequestData.ast),
+      typeIDKey: this._typeIDKey,
+    };
+
+    return this._cacheResponse(requestData, updatedRequestData, rawResponseData, options, cacheManagerContext);
+  }
+
+  public async cacheResponse(
+    requestData: RequestData,
+    rawResponseData: RawResponseDataWithMaybeCacheMetadata,
+    options: RequestOptions,
+    context: RequestContext,
+  ): Promise<ResponseData> {
+    const cacheManagerContext: CacheManagerContext = {
+      ...context,
+      fragmentDefinitions: getFragmentDefinitions(requestData.ast),
+      typeIDKey: this._typeIDKey,
+    };
+
+    return this._cacheResponse(requestData, undefined, rawResponseData, options, cacheManagerContext);
+  }
+
   public async checkCacheEntry(
     cacheType: CacheTypes,
     hash: string,
@@ -315,83 +351,6 @@ export class CacheManager implements CacheManagerDef {
     this._partialQueryResponses.delete(hash);
   }
 
-  public async resolveQuery(
-    requestData: RequestData,
-    updatedRequestData: RequestData,
-    rawResponseData: RawResponseDataWithMaybeCacheMetadata,
-    options: RequestOptions,
-    context: RequestContext,
-  ): Promise<ResponseData> {
-    const cacheManagerContext: CacheManagerContext = {
-      ...context,
-      fragmentDefinitions: getFragmentDefinitions(updatedRequestData.ast),
-      typeIDKey: this._typeIDKey,
-    };
-
-    const dataCaching: Promise<void>[] = [];
-
-    const { cacheMetadata, data, hasNext, path } = await this._resolveRequest(
-      updatedRequestData,
-      rawResponseData,
-      options,
-      cacheManagerContext,
-    );
-
-    let partialQueryResponse: PartialQueryResponse | undefined;
-
-    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._mergeResponseCacheMetadata(cacheMetadata, 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);
-    }
-
-    return { cacheMetadata: responseCacheMetadata, data: responseData, hasNext, path };
-  }
-
-  public async resolveRequest(
-    requestData: RequestData,
-    rawResponseData: RawResponseDataWithMaybeCacheMetadata,
-    options: RequestOptions,
-    context: RequestContext,
-  ): Promise<ResponseData> {
-    const cacheManagerContext: CacheManagerContext = {
-      ...context,
-      fragmentDefinitions: getFragmentDefinitions(requestData.ast),
-      typeIDKey: this._typeIDKey,
-    };
-
-    return this._resolveRequest(requestData, rawResponseData, options, cacheManagerContext);
-  }
-
   private async _analyzeFieldNode(
     fieldNode: FieldNode,
     cachedAncestorFieldData: CachedAncestorFieldData,
@@ -399,7 +358,7 @@ export class CacheManager implements CacheManagerDef {
     options: RequestOptions,
     context: CacheManagerContext,
   ): Promise<void> {
-    if (hasChildFields(fieldNode)) {
+    if (hasChildFields(fieldNode, { fragmentDefinitions: context.fragmentDefinitions })) {
       await this._analyzeParentFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
     } else {
       await this._analyzeLeafFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
@@ -556,6 +515,93 @@ export class CacheManager implements CacheManagerDef {
     return cacheMetadata;
   }
 
+  private async _cacheResponse(
+    requestData: RequestData,
+    updatedRequestData: RequestData | undefined,
+    rawResponseData: RawResponseDataWithMaybeCacheMetadata,
+    options: RequestOptions,
+    context: CacheManagerContext,
+  ): Promise<ResponseData> {
+    const normalizedResponseData = normalizePatchResponseData(rawResponseData, context);
+    let responseDataForCaching: RawResponseDataWithMaybeCacheMetadata | undefined = normalizedResponseData;
+
+    if (isNotLastResponseChunk(rawResponseData, context)) {
+      this._setResponseChunksAwaitingCaching(normalizedResponseData, context);
+      responseDataForCaching = undefined;
+    }
+
+    if (isLastResponseChunk(rawResponseData, context)) {
+      responseDataForCaching = this._retrieveResponseDataForCaching(normalizedResponseData, context);
+    }
+
+    const dataCaching: Promise<void>[] = [];
+
+    if (responseDataForCaching) {
+      const { data } = responseDataForCaching;
+      const cacheMetadata = this._buildCacheMetadata(requestData, responseDataForCaching, options, context);
+
+      dataCaching.push(
+        this._setEntityAndRequestFieldPathCacheEntries(
+          requestData,
+          {
+            cacheMetadata,
+            entityData: cloneDeep(data),
+            requestFieldPathData: cloneDeep(data),
+          },
+          options,
+          context,
+        ),
+      );
+
+      let queryCacheMetadata: CacheMetadata | undefined;
+      let queryData: PlainObjectMap | undefined;
+
+      if (context.operation === QUERY) {
+        let partialQueryResponse: PartialQueryResponse | undefined;
+
+        if (context.queryFiltered && updatedRequestData) {
+          dataCaching.push(
+            this._setQueryResponseCacheEntry(updatedRequestData.hash, { cacheMetadata, data }, options, context),
+          );
+
+          partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
+        }
+
+        queryCacheMetadata = CacheManager._mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse);
+        queryData = this._mergeResponseData(data, partialQueryResponse);
+
+        dataCaching.push(
+          this._setQueryResponseCacheEntry(
+            requestData.hash,
+            { cacheMetadata: queryCacheMetadata, data: queryData },
+            options,
+            context,
+          ),
+        );
+      }
+
+      if (options.awaitDataCaching) {
+        await Promise.all(dataCaching);
+      }
+
+      if (isNotResponseChunk(normalizedResponseData, context) && queryCacheMetadata && queryData) {
+        return {
+          cacheMetadata: queryCacheMetadata,
+          data: queryData,
+        };
+      }
+    }
+
+    const { data, hasNext, paths } = normalizedResponseData;
+
+    return {
+      cacheMetadata: this._buildCacheMetadata(requestData, normalizedResponseData, options, context),
+      data,
+      hasNext,
+      paths,
+    };
+  }
+
   private async _checkCacheEntry(
     cacheType: CacheTypes,
     hash: string,
@@ -717,33 +763,6 @@ export class CacheManager implements CacheManagerDef {
     );
   }
 
-  private async _resolveRequest(
-    requestData: RequestData,
-    rawResponseData: RawResponseDataWithMaybeCacheMetadata,
-    options: RequestOptions,
-    context: CacheManagerContext,
-  ): Promise<ResponseData> {
-    const normalizedResponseData = rawResponseData.path ? normalizeResponseData(rawResponseData) : rawResponseData;
-    const dataCaching: Promise<void>[] = [];
-    const cacheMetadata = this._buildCacheMetadata(requestData, normalizedResponseData, options, context);
-    const { data, hasNext, path } = normalizedResponseData;
-
-    dataCaching.push(
-      this._setEntityAndRequestFieldPathCacheEntries(
-        requestData,
-        { cacheMetadata, entityData: cloneDeep(data), requestFieldPathData: cloneDeep(data) },
-        options,
-        context,
-      ),
-    );
-
-    if (options.awaitDataCaching) {
-      await Promise.all(dataCaching);
-    }
-
-    return { cacheMetadata, data, hasNext, path };
-  }
-
   private async _retrieveCachedEntityData(
     validTypeIDValue: string | number,
     { possibleTypes, typeName }: FieldTypeInfo,
@@ -875,6 +894,18 @@ export class CacheManager implements CacheManagerDef {
     return cachedResponseData;
   }
 
+  private _retrieveResponseDataForCaching(
+    normalizedResponseData: RawResponseDataWithMaybeCacheMetadata,
+    context: CacheManagerContext,
+  ) {
+    const responseChunks = this._responseChunksAwaitingCaching.get(
+      context.boxID,
+    ) as RawResponseDataWithMaybeCacheMetadata[];
+
+    this._responseChunksAwaitingCaching.delete(context.boxID);
+    return mergeResponseDataSets([...responseChunks, normalizedResponseData]);
+  }
+
   @logCacheEntry()
   private async _setCacheEntry(
     cacheType: CacheTypes,
@@ -1115,7 +1146,7 @@ export class CacheManager implements CacheManagerDef {
         context,
       );
 
-      if (hasChildFields(field)) {
+      if (hasChildFields(field, { fragmentDefinitions: context.fragmentDefinitions })) {
         if (isEntity) {
           set(data, responseDataPath, { __cacheKey: `${REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}` });
         } else {
@@ -1124,6 +1155,19 @@ export class CacheManager implements CacheManagerDef {
       }
     }
   }
+
+  private _setResponseChunksAwaitingCaching(
+    normalizedResponseData: RawResponseDataWithMaybeCacheMetadata,
+    context: CacheManagerContext,
+  ) {
+    const responseChunks = this._responseChunksAwaitingCaching.get(context.boxID);
+
+    if (responseChunks) {
+      this._responseChunksAwaitingCaching.set(context.boxID, [...responseChunks, normalizedResponseData]);
+    } else {
+      this._responseChunksAwaitingCaching.set(context.boxID, [normalizedResponseData]);
+    }
+  }
 }
 
 export default function init(userOptions: UserOptions): CacheManagerInit {

package/lib/main/helpers/normalizeResponseData.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/helpers/normalizeResponseData.ts"],"names":["data","path","rest"],"mappings":";;;;;;;;;;;eAGe,CAAC;AAAEA,EAAAA,IAAF;AAAQC,EAAAA,IAAR;AAAc,KAAGC;AAAjB,CAAD,KAAoE;AACjF,SAAO,EACL,GAAGA,IADE;AAELF,IAAAA,IAAI,EAAE,mBAAI,EAAJ,EAAQC,IAAR,EAAqCD,IAArC,CAFD;AAGLC,IAAAA;AAHK,GAAP;AAKD,C","sourcesContent":["import { RawResponseDataWithMaybeCacheMetadata } from \"@graphql-box/core\";\nimport { set } from \"lodash\";\n\nexport default ({ data, path, ...rest }: RawResponseDataWithMaybeCacheMetadata) => {\n  return {\n    ...rest,\n    data: set({}, path as (string | number)[], data),\n    path,\n  };\n};\n"],"file":"normalizeResponseData.js"}

package/lib/module/helpers/normalizeResponseData.js

@@ -1,12 +0,0 @@
-import _set from "lodash/set";
-export default (({
-  data,
-  path,
-  ...rest
-}) => {
-  return { ...rest,
-    data: _set({}, path, data),
-    path
-  };
-});
-//# sourceMappingURL=normalizeResponseData.js.map

package/lib/module/helpers/normalizeResponseData.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/helpers/normalizeResponseData.ts"],"names":["data","path","rest"],"mappings":";AAGA,gBAAe,CAAC;AAAEA,EAAAA,IAAF;AAAQC,EAAAA,IAAR;AAAc,KAAGC;AAAjB,CAAD,KAAoE;AACjF,SAAO,EACL,GAAGA,IADE;AAELF,IAAAA,IAAI,EAAE,KAAI,EAAJ,EAAQC,IAAR,EAAqCD,IAArC,CAFD;AAGLC,IAAAA;AAHK,GAAP;AAKD,CAND","sourcesContent":["import { RawResponseDataWithMaybeCacheMetadata } from \"@graphql-box/core\";\nimport { set } from \"lodash\";\n\nexport default ({ data, path, ...rest }: RawResponseDataWithMaybeCacheMetadata) => {\n  return {\n    ...rest,\n    data: set({}, path as (string | number)[], data),\n    path,\n  };\n};\n"],"file":"normalizeResponseData.js"}

package/lib/types/helpers/normalizeResponseData.d.ts

@@ -1,11 +0,0 @@
-import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
-declare const _default: ({ data, path, ...rest }: RawResponseDataWithMaybeCacheMetadata) => {
-    data: {};
-    path: (string | number)[] | undefined;
-    _cacheMetadata?: import("@graphql-box/core").DehydratedCacheMetadata | undefined;
-    hasNext?: boolean | undefined;
-    headers?: Headers | undefined;
-    label?: string | undefined;
-};
-export default _default;
-//# sourceMappingURL=normalizeResponseData.d.ts.map

package/lib/types/helpers/normalizeResponseData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalizeResponseData.d.ts","sourceRoot":"","sources":["../../../src/helpers/normalizeResponseData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qCAAqC,EAAE,MAAM,mBAAmB,CAAC;kDAGjC,qCAAqC;;;;;;;;AAA9E,wBAME"}

package/src/helpers/normalizeResponseData.ts

@@ -1,10 +0,0 @@
-import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
-import { set } from "lodash";
-
-export default ({ data, path, ...rest }: RawResponseDataWithMaybeCacheMetadata) => {
-  return {
-    ...rest,
-    data: set({}, path as (string | number)[], data),
-    path,
-  };
-};