@graphql-box/cache-manager 2.4.1 → 3.0.0

package/lib/module/main/index.js

@@ -23,28 +23,13 @@ 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 let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec3 = logPartialCompiled(), (_class = class CacheManager {
-  static async init(options) {
-    const errors = [];
-
-    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);
-  }
-
   static _countFieldPathChecklist(fieldPathChecklist) {
     const fieldCount = {
       missing: 0,
@@ -197,22 +182,32 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
 
     _defineProperty(this, "_partialQueryResponses", new Map());
 
+    _defineProperty(this, "_responseChunksAwaitingCaching", new Map());
+
     _defineProperty(this, "_typeCacheDirectives", void 0);
 
     _defineProperty(this, "_typeIDKey", void 0);
 
-    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 = [];
+
+    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() {
@@ -288,6 +283,22 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     };
   }
 
+  async cacheQuery(requestData, updatedRequestData, rawResponseData, options, context) {
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: getFragmentDefinitions(updatedRequestData.ast),
+      typeIDKey: this._typeIDKey
+    };
+    return this._cacheResponse(requestData, updatedRequestData, rawResponseData, options, cacheManagerContext);
+  }
+
+  async cacheResponse(requestData, rawResponseData, options, context) {
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: getFragmentDefinitions(requestData.ast),
+      typeIDKey: this._typeIDKey
+    };
+    return this._cacheResponse(requestData, undefined, rawResponseData, options, cacheManagerContext);
+  }
+
   async checkCacheEntry(cacheType, hash, options, context) {
     return this._checkCacheEntry(cacheType, hash, options, context);
   }
@@ -313,66 +324,10 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     this._partialQueryResponses.delete(hash);
   }
 
-  async resolveQuery(requestData, updatedRequestData, rawResponseData, options, context) {
-    const cacheManagerContext = { ...context,
-      fragmentDefinitions: getFragmentDefinitions(updatedRequestData.ast),
-      typeIDKey: this._typeIDKey
-    };
-    const dataCaching = [];
-    const {
-      cacheMetadata,
-      data,
-      hasNext,
-      paths
-    } = await this._resolveRequest(updatedRequestData, rawResponseData, options, cacheManagerContext);
-    let partialQueryResponse;
-
-    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
-    };
-  }
-
-  async resolveRequest(requestData, rawResponseData, options, context) {
-    const cacheManagerContext = { ...context,
-      fragmentDefinitions: getFragmentDefinitions(requestData.ast),
-      typeIDKey: this._typeIDKey
-    };
-    return this._resolveRequest(requestData, rawResponseData, options, cacheManagerContext);
-  }
-
   async _analyzeFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
-    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);
@@ -507,6 +462,81 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     return cacheMetadata;
   }
 
+  async _cacheResponse(requestData, updatedRequestData, rawResponseData, options, context) {
+    const normalizedResponseData = normalizePatchResponseData(rawResponseData, context);
+    let responseDataForCaching = normalizedResponseData;
+
+    if (isNotLastResponseChunk(rawResponseData, context)) {
+      this._setResponseChunksAwaitingCaching(normalizedResponseData, context);
+
+      responseDataForCaching = undefined;
+    }
+
+    if (isLastResponseChunk(rawResponseData, context)) {
+      responseDataForCaching = this._retrieveResponseDataForCaching(normalizedResponseData, context);
+    }
+
+    const dataCaching = [];
+
+    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;
+      let queryData;
+
+      if (context.operation === QUERY) {
+        let partialQueryResponse;
+
+        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
+    };
+  }
+
   async _checkCacheEntry(cacheType, hash, options, context) {
     try {
       const cacheability = await this._hasCacheEntry(cacheType, hash);
@@ -652,35 +682,6 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     }, options, context);
   }
 
-  async _resolveRequest(requestData, rawResponseData, options, context) {
-    const normalizedResponseData = rawResponseData.paths ? normalizeResponseData(rawResponseData) : rawResponseData;
-    const dataCaching = [];
-
-    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
-    };
-  }
-
   async _retrieveCachedEntityData(validTypeIDValue, {
     possibleTypes,
     typeName
@@ -799,6 +800,14 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     return cachedResponseData;
   }
 
+  _retrieveResponseDataForCaching(normalizedResponseData, context) {
+    const responseChunks = this._responseChunksAwaitingCaching.get(context.boxID);
+
+    this._responseChunksAwaitingCaching.delete(context.boxID);
+
+    return mergeResponseDataSets([...responseChunks, normalizedResponseData]);
+  }
+
   async _setCacheEntry(cacheType, hash, value, cachemapOptions, _options, _context) {
     try {
       await this._cache.set(`${cacheType}::${hash}`, _cloneDeep(value), cachemapOptions);
@@ -1017,7 +1026,9 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
         tag: options.tag
       }, options, context);
 
-      if (hasChildFields(field)) {
+      if (hasChildFields(field, {
+        fragmentDefinitions: context.fragmentDefinitions
+      })) {
         if (isEntity) {
           _set(data, responseDataPath, {
             __cacheKey: `${REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}`
@@ -1029,13 +1040,23 @@ export let CacheManager = (_dec = logCacheQuery(), _dec2 = logCacheEntry(), _dec
     }
   }
 
+  _setResponseChunksAwaitingCaching(normalizedResponseData, context) {
+    const responseChunks = this._responseChunksAwaitingCaching.get(context.boxID);
+
+    if (responseChunks) {
+      this._responseChunksAwaitingCaching.set(context.boxID, [...responseChunks, normalizedResponseData]);
+    } else {
+      this._responseChunksAwaitingCaching.set(context.boxID, [normalizedResponseData]);
+    }
+  }
+
 }, (_applyDecoratedDescriptor(_class.prototype, "_getCacheEntry", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "_getCacheEntry"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "_setCacheEntry", [_dec2], Object.getOwnPropertyDescriptor(_class.prototype, "_setCacheEntry"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "_setPartialQueryResponse", [_dec3], Object.getOwnPropertyDescriptor(_class.prototype, "_setPartialQueryResponse"), _class.prototype)), _class));
 export default function init(userOptions) {
   if (!_isPlainObject(userOptions)) {
     throw new TypeError("@graphql-box/cache-manager expected userOptions to be a plain object.");
   }
 
-  return clientOptions => CacheManager.init({ ...clientOptions,
+  return clientOptions => new CacheManager({ ...clientOptions,
     ...userOptions
   });
 }