relay-runtime 11.0.0 → 13.0.0-rc.0

package/lib/store/RelayOperationTracker.js

@@ -14,13 +14,13 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var RelayOperationTracker = /*#__PURE__*/function () {
   function RelayOperationTracker() {
-    this._ownersToPendingOperationsIdentifier = new Map();
-    this._pendingOperationsToOwnersIdentifier = new Map();
-    this._ownersIdentifierToPromise = new Map();
+    this._ownersToPendingOperations = new Map();
+    this._pendingOperationsToOwners = new Map();
+    this._ownersToPendingPromise = new Map();
   }
   /**
    * Update the map of current processing operations with the set of
@@ -46,19 +46,19 @@ var RelayOperationTracker = /*#__PURE__*/function () {
         var owner = _step.value;
         var ownerIdentifier = owner.identifier;
 
-        var pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(ownerIdentifier);
+        var pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(ownerIdentifier);
 
         if (pendingOperationsAffectingOwner != null) {
           // In this case the `ownerIdentifier` already affected by some operations
           // We just need to detect, is it the same operation that we already
           // have in the list, or it's a new operation
           if (!pendingOperationsAffectingOwner.has(pendingOperationIdentifier)) {
-            pendingOperationsAffectingOwner.add(pendingOperationIdentifier);
+            pendingOperationsAffectingOwner.set(pendingOperationIdentifier, pendingOperation);
             newlyAffectedOwnersIdentifier.add(ownerIdentifier);
           }
         } else {
           // This is a new `ownerIdentifier` that is affected by the operation
-          this._ownersToPendingOperationsIdentifier.set(ownerIdentifier, new Set([pendingOperationIdentifier]));
+          this._ownersToPendingOperations.set(ownerIdentifier, new Map([[pendingOperationIdentifier, pendingOperation]]));
 
           newlyAffectedOwnersIdentifier.add(ownerIdentifier);
         }
@@ -73,10 +73,10 @@ var RelayOperationTracker = /*#__PURE__*/function () {
     if (newlyAffectedOwnersIdentifier.size === 0) {
       return;
     } // But, if some owners were affected we need to add them to
-    // the `_pendingOperationsToOwnersIdentifier` set
+    // the `_pendingOperationsToOwners` set
 
 
-    var ownersAffectedByOperationIdentifier = this._pendingOperationsToOwnersIdentifier.get(pendingOperationIdentifier) || new Set();
+    var ownersAffectedByPendingOperation = this._pendingOperationsToOwners.get(pendingOperationIdentifier) || new Set();
 
     var _iterator2 = (0, _createForOfIteratorHelper2["default"])(newlyAffectedOwnersIdentifier),
         _step2;
@@ -87,7 +87,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
 
         this._resolveOwnerResolvers(_ownerIdentifier);
 
-        ownersAffectedByOperationIdentifier.add(_ownerIdentifier);
+        ownersAffectedByPendingOperation.add(_ownerIdentifier);
       }
     } catch (err) {
       _iterator2.e(err);
@@ -95,7 +95,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
       _iterator2.f();
     }
 
-    this._pendingOperationsToOwnersIdentifier.set(pendingOperationIdentifier, ownersAffectedByOperationIdentifier);
+    this._pendingOperationsToOwners.set(pendingOperationIdentifier, ownersAffectedByPendingOperation);
   }
   /**
    * Once pending operation is completed we need to remove it
@@ -106,7 +106,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
   _proto.complete = function complete(pendingOperation) {
     var pendingOperationIdentifier = pendingOperation.identifier;
 
-    var affectedOwnersIdentifier = this._pendingOperationsToOwnersIdentifier.get(pendingOperationIdentifier);
+    var affectedOwnersIdentifier = this._pendingOperationsToOwners.get(pendingOperationIdentifier);
 
     if (affectedOwnersIdentifier == null) {
       return;
@@ -125,7 +125,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
       for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
         var ownerIdentifier = _step3.value;
 
-        var pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(ownerIdentifier);
+        var pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(ownerIdentifier);
 
         if (!pendingOperationsAffectingOwner) {
           continue;
@@ -155,7 +155,7 @@ var RelayOperationTracker = /*#__PURE__*/function () {
 
         this._resolveOwnerResolvers(_ownerIdentifier2);
 
-        this._ownersToPendingOperationsIdentifier["delete"](_ownerIdentifier2);
+        this._ownersToPendingOperations["delete"](_ownerIdentifier2);
       } // Update all ownerIdentifier that were updated by `pendingOperationIdentifier` but still
       // are affected by other operations
 
@@ -181,30 +181,35 @@ var RelayOperationTracker = /*#__PURE__*/function () {
       _iterator5.f();
     }
 
-    this._pendingOperationsToOwnersIdentifier["delete"](pendingOperationIdentifier);
+    this._pendingOperationsToOwners["delete"](pendingOperationIdentifier);
   };
 
   _proto._resolveOwnerResolvers = function _resolveOwnerResolvers(ownerIdentifier) {
-    var promiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);
+    var promiseEntry = this._ownersToPendingPromise.get(ownerIdentifier);
 
     if (promiseEntry != null) {
       promiseEntry.resolve();
     }
 
-    this._ownersIdentifierToPromise["delete"](ownerIdentifier);
+    this._ownersToPendingPromise["delete"](ownerIdentifier);
   };
 
-  _proto.getPromiseForPendingOperationsAffectingOwner = function getPromiseForPendingOperationsAffectingOwner(owner) {
+  _proto.getPendingOperationsAffectingOwner = function getPendingOperationsAffectingOwner(owner) {
     var ownerIdentifier = owner.identifier;
 
-    if (!this._ownersToPendingOperationsIdentifier.has(ownerIdentifier)) {
+    var pendingOperationsForOwner = this._ownersToPendingOperations.get(ownerIdentifier);
+
+    if (pendingOperationsForOwner == null || pendingOperationsForOwner.size === 0) {
       return null;
     }
 
-    var cachedPromiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);
+    var cachedPromiseEntry = this._ownersToPendingPromise.get(ownerIdentifier);
 
     if (cachedPromiseEntry != null) {
-      return cachedPromiseEntry.promise;
+      return {
+        promise: cachedPromiseEntry.promise,
+        pendingOperations: cachedPromiseEntry.pendingOperations
+      };
     }
 
     var resolve;
@@ -212,13 +217,18 @@ var RelayOperationTracker = /*#__PURE__*/function () {
       resolve = r;
     });
     !(resolve != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayOperationTracker: Expected resolver to be defined. If you' + 'are seeing this, it is likely a bug in Relay.') : invariant(false) : void 0;
+    var pendingOperations = Array.from(pendingOperationsForOwner.values());
 
-    this._ownersIdentifierToPromise.set(ownerIdentifier, {
+    this._ownersToPendingPromise.set(ownerIdentifier, {
       promise: promise,
-      resolve: resolve
+      resolve: resolve,
+      pendingOperations: pendingOperations
     });
 
-    return promise;
+    return {
+      promise: promise,
+      pendingOperations: pendingOperations
+    };
   };
 
   return RelayOperationTracker;

package/lib/store/RelayPublishQueue.js

@@ -10,11 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var ErrorUtils = require("fbjs/lib/ErrorUtils");
-
-var RelayReader = require('./RelayReader');
-
-var RelayRecordSource = require('./RelayRecordSource');
+var _global$ErrorUtils$ap, _global, _global$ErrorUtils;
 
 var RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
 
@@ -22,10 +18,17 @@ var RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
 
 var RelayRecordSourceSelectorProxy = require('../mutations/RelayRecordSourceSelectorProxy');
 
-var invariant = require("fbjs/lib/invariant");
+var RelayReader = require('./RelayReader');
+
+var RelayRecordSource = require('./RelayRecordSource');
+
+var invariant = require('invariant');
 
 var warning = require("fbjs/lib/warning");
 
+var applyWithGuard = (_global$ErrorUtils$ap = (_global = global) === null || _global === void 0 ? void 0 : (_global$ErrorUtils = _global.ErrorUtils) === null || _global$ErrorUtils === void 0 ? void 0 : _global$ErrorUtils.applyWithGuard) !== null && _global$ErrorUtils$ap !== void 0 ? _global$ErrorUtils$ap : function (callback, context, args, onError, name) {
+  return callback.apply(context, args);
+};
 /**
  * Coordinates the concurrent modification of a `Store` due to optimistic and
  * non-revertable client updates and server payloads:
@@ -37,13 +40,20 @@ var warning = require("fbjs/lib/warning");
  *   - Executes handlers for "handle" fields.
  *   - Reverts and reapplies pending optimistic updates.
  */
+
 var RelayPublishQueue = /*#__PURE__*/function () {
   // True if the next `run()` should apply the backup and rerun all optimistic
   // updates performing a rebase.
   // Payloads to apply or Sources to publish to the store with the next `run()`.
+  // $FlowFixMe[unclear-type] See explanation below.
   // Optimistic updaters to add with the next `run()`.
+  // $FlowFixMe[unclear-type] See explanation below.
   // Optimistic updaters that are already added and might be rerun in order to
   // rebase them.
+  // $FlowFixMe[unclear-type] See explanation below.
+  // For _pendingOptimisticUpdates, _appliedOptimisticUpdates, and _pendingData,
+  // we want to parametrize by "any" since the type is effectively
+  // "the union of all T's that PublishQueue's methods were called with".
   // Garbage collection hold, should rerun gc on dispose
   function RelayPublishQueue(store, handlerProvider, getDataID) {
     this._hasStoreSnapshot = false;
@@ -145,11 +155,25 @@ var RelayPublishQueue = /*#__PURE__*/function () {
   ;
 
   _proto.run = function run(sourceOperation) {
+    var runWillClearGcHold = this._appliedOptimisticUpdates === 0 && !!this._gcHold;
+    var runIsANoop = // this._pendingBackupRebase is true if an applied optimistic
+    // update has potentially been reverted or if this._pendingData is not empty.
+    !this._pendingBackupRebase && this._pendingOptimisticUpdates.size === 0 && !runWillClearGcHold;
+
     if (process.env.NODE_ENV !== "production") {
+      process.env.NODE_ENV !== "production" ? warning(!runIsANoop, 'RelayPublishQueue.run was called, but the call would have been a noop.') : void 0;
       process.env.NODE_ENV !== "production" ? warning(this._isRunning !== true, 'A store update was detected within another store update. Please ' + "make sure new store updates aren't being executed within an " + 'updater function for a different update.') : void 0;
       this._isRunning = true;
     }
 
+    if (runIsANoop) {
+      if (process.env.NODE_ENV !== "production") {
+        this._isRunning = false;
+      }
+
+      return [];
+    }
+
     if (this._pendingBackupRebase) {
       if (this._hasStoreSnapshot) {
         this._store.restore();
@@ -259,7 +283,7 @@ var RelayPublishQueue = /*#__PURE__*/function () {
         var sink = RelayRecordSource.create();
         var mutator = new RelayRecordSourceMutator(_this2._store.getSource(), sink);
         var recordSourceProxy = new RelayRecordSourceProxy(mutator, _this2._getDataID);
-        ErrorUtils.applyWithGuard(updater, null, [recordSourceProxy], null, 'RelayPublishQueue:commitData');
+        applyWithGuard(updater, null, [recordSourceProxy], null, 'RelayPublishQueue:commitData');
         invalidatedStore = invalidatedStore || recordSourceProxy.isStoreMarkedForInvalidation();
         var idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();
 
@@ -283,28 +307,32 @@ var RelayPublishQueue = /*#__PURE__*/function () {
 
     var sink = RelayRecordSource.create();
     var mutator = new RelayRecordSourceMutator(this._store.getSource(), sink);
-    var recordSourceProxy = new RelayRecordSourceProxy(mutator, this._getDataID, this._handlerProvider);
+    var recordSourceProxy = new RelayRecordSourceProxy(mutator, this._getDataID, this._handlerProvider); // $FlowFixMe[unclear-type] see explanation above.
 
     var processUpdate = function processUpdate(optimisticUpdate) {
       if (optimisticUpdate.storeUpdater) {
         var storeUpdater = optimisticUpdate.storeUpdater;
-        ErrorUtils.applyWithGuard(storeUpdater, null, [recordSourceProxy], null, 'RelayPublishQueue:applyUpdates');
+        applyWithGuard(storeUpdater, null, [recordSourceProxy], null, 'RelayPublishQueue:applyUpdates');
       } else {
         var operation = optimisticUpdate.operation,
             payload = optimisticUpdate.payload,
             updater = optimisticUpdate.updater;
         var source = payload.source,
             fieldPayloads = payload.fieldPayloads;
-        var recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(mutator, recordSourceProxy, operation.fragment);
-        var selectorData;
 
         if (source) {
           recordSourceProxy.publishSource(source, fieldPayloads);
-          selectorData = lookupSelector(source, operation.fragment);
         }
 
         if (updater) {
-          ErrorUtils.applyWithGuard(updater, null, [recordSourceSelectorProxy, selectorData], null, 'RelayPublishQueue:applyUpdates');
+          var selectorData;
+
+          if (source) {
+            selectorData = lookupSelector(source, operation.fragment);
+          }
+
+          var recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(mutator, recordSourceProxy, operation.fragment);
+          applyWithGuard(updater, null, [recordSourceSelectorProxy, selectorData], null, 'RelayPublishQueue:applyUpdates');
         }
       }
     }; // rerun all updaters in case we are running a rebase