@graphql-box/cache-manager 2.4.2 → 3.1.0

package/src/main/index.ts

@@ -49,7 +49,6 @@ import {
   FieldCount,
   FieldPathChecklist,
   FieldPathChecklistValue,
-  InitOptions,
   KeysAndPaths,
   MergedCachedFieldData,
   PartialQueryResponse,
@@ -63,29 +62,14 @@ import { buildFieldKeysAndPaths } from "../helpers/buildKeysAndPaths";
 import deriveOpCacheability from "../helpers/deriveOpCacheability";
 import filterOutPropsWithArgsOrDirectives from "../helpers/filterOutPropsWithArgsOrDirectives";
 import filterQuery from "../helpers/filterQuery";
+import isLastResponseChunk from "../helpers/isLastResponseChunk";
+import isNotLastResponseChunk from "../helpers/isNotLastResponseChunk";
+import isNotResponseChunk from "../helpers/isNotResponseChunk";
+import mergeResponseDataSets from "../helpers/mergeResponseDataSets";
 import normalizePatchResponseData from "../helpers/normalizePatchResponseData";
 import { getValidTypeIDValue } from "../helpers/validTypeIDValue";
 
 export class CacheManager implements CacheManagerDef {
-  public static async init(options: InitOptions): Promise<CacheManager> {
-    const errors: TypeError[] = [];
-
-    if (!options.cache) {
-      errors.push(new TypeError("@graphql-box/cache-manager expected options.cache."));
-    }
-
-    if (!!options.typeCacheDirectives && !isPlainObject(options.typeCacheDirectives)) {
-      const message = "@graphql-box/cache-manager expected options.typeCacheDirectives to be a plain object.";
-      errors.push(new TypeError(message));
-    }
-
-    if (errors.length) {
-      return Promise.reject(errors);
-    }
-
-    return new CacheManager(options);
-  }
-
   private static _countFieldPathChecklist(fieldPathChecklist: FieldPathChecklist): FieldCount {
     const fieldCount: FieldCount = { missing: 0, total: 0 };
 
@@ -225,16 +209,31 @@ 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;
 
   constructor(options: ConstructorOptions) {
-    const { cache, cascadeCacheControl, fallbackOperationCacheability, typeCacheDirectives, typeIDKey } = options;
-    this._cache = cache;
-    this._cascadeCacheControl = cascadeCacheControl || false;
-    this._fallbackOperationCacheability = fallbackOperationCacheability || NO_CACHE;
-    this._typeCacheDirectives = typeCacheDirectives || {};
-    this._typeIDKey = typeIDKey;
+    const errors: TypeError[] = [];
+
+    if (!options.cache) {
+      errors.push(new TypeError("@graphql-box/cache-manager expected options.cache."));
+    }
+
+    if (!!options.typeCacheDirectives && !isPlainObject(options.typeCacheDirectives)) {
+      const message = "@graphql-box/cache-manager expected options.typeCacheDirectives to be a plain object.";
+      errors.push(new TypeError(message));
+    }
+
+    if (errors.length) {
+      throw errors;
+    }
+
+    this._cache = options.cache;
+    this._cascadeCacheControl = options.cascadeCacheControl || false;
+    this._fallbackOperationCacheability = options.fallbackOperationCacheability || NO_CACHE;
+    this._typeCacheDirectives = options.typeCacheDirectives || {};
+    this._typeIDKey = options.typeIDKey;
   }
 
   get cache(): Cachemap {
@@ -283,6 +282,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 +345,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, paths } = await this._resolveRequest(
-      updatedRequestData,
-      rawResponseData,
-      options,
-      cacheManagerContext,
-    );
-
-    let partialQueryResponse: PartialQueryResponse | undefined;
-
-    if (cacheManagerContext.queryFiltered) {
-      if (!(rawResponseData.hasNext || rawResponseData.paths)) {
-        dataCaching.push(
-          this._setQueryResponseCacheEntry(
-            updatedRequestData.hash,
-            { cacheMetadata, data },
-            options,
-            cacheManagerContext,
-          ),
-        );
-      }
-
-      if (!rawResponseData.paths) {
-        partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
-      }
-    }
-
-    const responseCacheMetadata = CacheManager._mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse);
-    const responseData = this._mergeResponseData(data, partialQueryResponse);
-
-    if (!(rawResponseData.hasNext || rawResponseData.paths)) {
-      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, paths };
-  }
-
-  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 +352,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 +509,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,37 +757,6 @@ export class CacheManager implements CacheManagerDef {
     );
   }
 
-  private async _resolveRequest(
-    requestData: RequestData,
-    rawResponseData: RawResponseDataWithMaybeCacheMetadata,
-    options: RequestOptions,
-    context: CacheManagerContext,
-  ): Promise<ResponseData> {
-    const normalizedResponseData =
-      rawResponseData.paths && context.normalizePatchResponseData
-        ? normalizePatchResponseData(rawResponseData)
-        : rawResponseData;
-
-    const dataCaching: Promise<void>[] = [];
-    const cacheMetadata = this._buildCacheMetadata(requestData, normalizedResponseData, options, context);
-    const { data, hasNext, paths } = 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, paths };
-  }
-
   private async _retrieveCachedEntityData(
     validTypeIDValue: string | number,
     { possibleTypes, typeName }: FieldTypeInfo,
@@ -879,6 +888,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,
@@ -1119,7 +1140,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 {
@@ -1128,6 +1149,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 {
@@ -1135,5 +1169,5 @@ export default function init(userOptions: UserOptions): CacheManagerInit {
     throw new TypeError("@graphql-box/cache-manager expected userOptions to be a plain object.");
   }
 
-  return (clientOptions: ClientOptions) => CacheManager.init({ ...clientOptions, ...userOptions });
+  return (clientOptions: ClientOptions) => new CacheManager({ ...clientOptions, ...userOptions });
 }