@graphql-box/cache-manager 2.4.1 → 3.0.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 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 {
-  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,33 +757,6 @@ export class CacheManager implements CacheManagerDef {
     );
   }
 
-  private async _resolveRequest(
-    requestData: RequestData,
-    rawResponseData: RawResponseDataWithMaybeCacheMetadata,
-    options: RequestOptions,
-    context: CacheManagerContext,
-  ): Promise<ResponseData> {
-    const normalizedResponseData = rawResponseData.paths ? normalizeResponseData(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,
@@ -875,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,
@@ -1115,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 {
@@ -1124,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 {
@@ -1131,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 });
 }

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/helpers/normalizeResponseData.ts"],"names":["data","paths","rest"],"mappings":";;;;;;;;;;;eAGe,CAAC;AAAEA,EAAAA,IAAF;AAAQC,EAAAA,KAAR;AAAe,KAAGC;AAAlB,CAAD,KAAqE;AAClF,SAAO,EACL,GAAGA,IADE;AAELF,IAAAA,IAAI,EAAE,mBAAI,EAAJ,EAASC,KAAD,CAAoB,CAApB,CAAR,EAAgCD,IAAhC,CAFD;AAGLC,IAAAA;AAHK,GAAP;AAKD,C","sourcesContent":["import { RawResponseDataWithMaybeCacheMetadata } from \"@graphql-box/core\";\nimport { set } from \"lodash\";\n\nexport default ({ data, paths, ...rest }: RawResponseDataWithMaybeCacheMetadata) => {\n  return {\n    ...rest,\n    data: set({}, (paths as string[])[0], data),\n    paths,\n  };\n};\n"],"file":"normalizeResponseData.js"}

package/lib/module/helpers/normalizeResponseData.js

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/helpers/normalizeResponseData.ts"],"names":["data","paths","rest"],"mappings":";AAGA,gBAAe,CAAC;AAAEA,EAAAA,IAAF;AAAQC,EAAAA,KAAR;AAAe,KAAGC;AAAlB,CAAD,KAAqE;AAClF,SAAO,EACL,GAAGA,IADE;AAELF,IAAAA,IAAI,EAAE,KAAI,EAAJ,EAASC,KAAD,CAAoB,CAApB,CAAR,EAAgCD,IAAhC,CAFD;AAGLC,IAAAA;AAHK,GAAP;AAKD,CAND","sourcesContent":["import { RawResponseDataWithMaybeCacheMetadata } from \"@graphql-box/core\";\nimport { set } from \"lodash\";\n\nexport default ({ data, paths, ...rest }: RawResponseDataWithMaybeCacheMetadata) => {\n  return {\n    ...rest,\n    data: set({}, (paths as string[])[0], data),\n    paths,\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, paths, ...rest }: RawResponseDataWithMaybeCacheMetadata) => {
-    data: {};
-    paths: string[] | 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;mDAGhC,qCAAqC;;;;;;;;AAA/E,wBAME"}

package/src/helpers/normalizeResponseData.ts

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