@graphql-box/cache-manager 2.4.1 → 3.0.0

package/lib/main/main/index.js

@@ -52,32 +52,21 @@ var _filterOutPropsWithArgsOrDirectives = _interopRequireDefault(require("../hel
 
 var _filterQuery = _interopRequireDefault(require("../helpers/filterQuery"));
 
-var _normalizeResponseData = _interopRequireDefault(require("../helpers/normalizeResponseData"));
+var _isLastResponseChunk = _interopRequireDefault(require("../helpers/isLastResponseChunk"));
 
-var _validTypeIDValue = require("../helpers/validTypeIDValue");
+var _isNotLastResponseChunk = _interopRequireDefault(require("../helpers/isNotLastResponseChunk"));
 
-var _dec, _dec2, _dec3, _class;
+var _isNotResponseChunk = _interopRequireDefault(require("../helpers/isNotResponseChunk"));
 
-let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCacheEntry)(), _dec3 = (0, _debug.logPartialCompiled)(), (_class = class CacheManager {
-  static async init(options) {
-    const errors = [];
+var _mergeResponseDataSets = _interopRequireDefault(require("../helpers/mergeResponseDataSets"));
 
-    if (!options.cache) {
-      errors.push(new TypeError("@graphql-box/cache-manager expected options.cache."));
-    }
+var _normalizePatchResponseData = _interopRequireDefault(require("../helpers/normalizePatchResponseData"));
 
-    if (!!options.typeCacheDirectives && !(0, _isPlainObject2.default)(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);
-    }
+var _validTypeIDValue = require("../helpers/validTypeIDValue");
 
-    return new CacheManager(options);
-  }
+var _dec, _dec2, _dec3, _class;
 
+let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCacheEntry)(), _dec3 = (0, _debug.logPartialCompiled)(), (_class = class CacheManager {
   static _countFieldPathChecklist(fieldPathChecklist) {
     const fieldCount = {
       missing: 0,
@@ -225,20 +214,29 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     (0, _defineProperty2.default)(this, "_cascadeCacheControl", void 0);
     (0, _defineProperty2.default)(this, "_fallbackOperationCacheability", void 0);
     (0, _defineProperty2.default)(this, "_partialQueryResponses", new Map());
+    (0, _defineProperty2.default)(this, "_responseChunksAwaitingCaching", new Map());
     (0, _defineProperty2.default)(this, "_typeCacheDirectives", void 0);
     (0, _defineProperty2.default)(this, "_typeIDKey", void 0);
-    const {
-      cache,
-      cascadeCacheControl,
-      fallbackOperationCacheability,
-      typeCacheDirectives,
-      typeIDKey
-    } = options;
-    this._cache = cache;
-    this._cascadeCacheControl = cascadeCacheControl || false;
-    this._fallbackOperationCacheability = fallbackOperationCacheability || _consts.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 && !(0, _isPlainObject2.default)(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 || _consts.NO_CACHE;
+    this._typeCacheDirectives = options.typeCacheDirectives || {};
+    this._typeIDKey = options.typeIDKey;
   }
 
   get cache() {
@@ -312,6 +310,22 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     };
   }
 
+  async cacheQuery(requestData, updatedRequestData, rawResponseData, options, context) {
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: (0, _helpers.getFragmentDefinitions)(updatedRequestData.ast),
+      typeIDKey: this._typeIDKey
+    };
+    return this._cacheResponse(requestData, updatedRequestData, rawResponseData, options, cacheManagerContext);
+  }
+
+  async cacheResponse(requestData, rawResponseData, options, context) {
+    const cacheManagerContext = { ...context,
+      fragmentDefinitions: (0, _helpers.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);
   }
@@ -337,66 +351,10 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     this._partialQueryResponses.delete(hash);
   }
 
-  async resolveQuery(requestData, updatedRequestData, rawResponseData, options, context) {
-    const cacheManagerContext = { ...context,
-      fragmentDefinitions: (0, _helpers.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: (0, _helpers.getFragmentDefinitions)(requestData.ast),
-      typeIDKey: this._typeIDKey
-    };
-    return this._resolveRequest(requestData, rawResponseData, options, cacheManagerContext);
-  }
-
   async _analyzeFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context) {
-    if ((0, _helpers.hasChildFields)(fieldNode)) {
+    if ((0, _helpers.hasChildFields)(fieldNode, {
+      fragmentDefinitions: context.fragmentDefinitions
+    })) {
       await this._analyzeParentFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
     } else {
       await this._analyzeLeafFieldNode(fieldNode, cachedAncestorFieldData, cachedResponseData, options, context);
@@ -531,6 +489,81 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     return cacheMetadata;
   }
 
+  async _cacheResponse(requestData, updatedRequestData, rawResponseData, options, context) {
+    const normalizedResponseData = (0, _normalizePatchResponseData.default)(rawResponseData, context);
+    let responseDataForCaching = normalizedResponseData;
+
+    if ((0, _isNotLastResponseChunk.default)(rawResponseData, context)) {
+      this._setResponseChunksAwaitingCaching(normalizedResponseData, context);
+
+      responseDataForCaching = undefined;
+    }
+
+    if ((0, _isLastResponseChunk.default)(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: (0, _cloneDeep2.default)(data),
+        requestFieldPathData: (0, _cloneDeep2.default)(data)
+      }, options, context));
+      let queryCacheMetadata;
+      let queryData;
+
+      if (context.operation === _core.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 ((0, _isNotResponseChunk.default)(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);
@@ -674,35 +707,6 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     }, options, context);
   }
 
-  async _resolveRequest(requestData, rawResponseData, options, context) {
-    const normalizedResponseData = rawResponseData.paths ? (0, _normalizeResponseData.default)(rawResponseData) : rawResponseData;
-    const dataCaching = [];
-
-    const cacheMetadata = this._buildCacheMetadata(requestData, normalizedResponseData, options, context);
-
-    const {
-      data,
-      hasNext,
-      paths
-    } = normalizedResponseData;
-    dataCaching.push(this._setEntityAndRequestFieldPathCacheEntries(requestData, {
-      cacheMetadata,
-      entityData: (0, _cloneDeep2.default)(data),
-      requestFieldPathData: (0, _cloneDeep2.default)(data)
-    }, options, context));
-
-    if (options.awaitDataCaching) {
-      await Promise.all(dataCaching);
-    }
-
-    return {
-      cacheMetadata,
-      data,
-      hasNext,
-      paths
-    };
-  }
-
   async _retrieveCachedEntityData(validTypeIDValue, {
     possibleTypes,
     typeName
@@ -821,6 +825,14 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     return cachedResponseData;
   }
 
+  _retrieveResponseDataForCaching(normalizedResponseData, context) {
+    const responseChunks = this._responseChunksAwaitingCaching.get(context.boxID);
+
+    this._responseChunksAwaitingCaching.delete(context.boxID);
+
+    return (0, _mergeResponseDataSets.default)([...responseChunks, normalizedResponseData]);
+  }
+
   async _setCacheEntry(cacheType, hash, value, cachemapOptions, _options, _context) {
     try {
       await this._cache.set(`${cacheType}::${hash}`, (0, _cloneDeep2.default)(value), cachemapOptions);
@@ -1032,7 +1044,9 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
         tag: options.tag
       }, options, context);
 
-      if ((0, _helpers.hasChildFields)(field)) {
+      if ((0, _helpers.hasChildFields)(field, {
+        fragmentDefinitions: context.fragmentDefinitions
+      })) {
         if (isEntity) {
           (0, _set2.default)(data, responseDataPath, {
             __cacheKey: `${_core.REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}`
@@ -1044,6 +1058,16 @@ let CacheManager = (_dec = (0, _debug.logCacheQuery)(), _dec2 = (0, _debug.logCa
     }
   }
 
+  _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]);
+    }
+  }
+
 }, ((0, _applyDecoratedDescriptor2.default)(_class.prototype, "_getCacheEntry", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "_getCacheEntry"), _class.prototype), (0, _applyDecoratedDescriptor2.default)(_class.prototype, "_setCacheEntry", [_dec2], Object.getOwnPropertyDescriptor(_class.prototype, "_setCacheEntry"), _class.prototype), (0, _applyDecoratedDescriptor2.default)(_class.prototype, "_setPartialQueryResponse", [_dec3], Object.getOwnPropertyDescriptor(_class.prototype, "_setPartialQueryResponse"), _class.prototype)), _class));
 exports.CacheManager = CacheManager;
 
@@ -1052,7 +1076,7 @@ function init(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
   });
 }