relay-runtime 11.0.1 → 13.0.0-rc.1

package/store/RelayOperationTracker.js.flow

@@ -12,22 +12,26 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
 import type {RequestDescriptor} from './RelayStoreTypes';
 
+const invariant = require('invariant');
+
 class RelayOperationTracker {
-  _ownersToPendingOperationsIdentifier: Map<string, Set<string>>;
-  _pendingOperationsToOwnersIdentifier: Map<string, Set<string>>;
-  _ownersIdentifierToPromise: Map<
+  _ownersToPendingOperations: Map<string, Map<string, RequestDescriptor>>;
+  _pendingOperationsToOwners: Map<string, Set<string>>;
+  _ownersToPendingPromise: Map<
     string,
-    {|promise: Promise<void>, resolve: () => void|},
+    {|
+      promise: Promise<void>,
+      resolve: () => void,
+      pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+    |},
   >;
 
   constructor() {
-    this._ownersToPendingOperationsIdentifier = new Map();
-    this._pendingOperationsToOwnersIdentifier = new Map();
-    this._ownersIdentifierToPromise = new Map();
+    this._ownersToPendingOperations = new Map();
+    this._pendingOperationsToOwners = new Map();
+    this._ownersToPendingPromise = new Map();
   }
 
   /**
@@ -45,22 +49,24 @@ class RelayOperationTracker {
     const newlyAffectedOwnersIdentifier = new Set();
     for (const owner of affectedOwners) {
       const ownerIdentifier = owner.identifier;
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(
-        ownerIdentifier,
-      );
+      const 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(
+        this._ownersToPendingOperations.set(
           ownerIdentifier,
-          new Set([pendingOperationIdentifier]),
+          new Map([[pendingOperationIdentifier, pendingOperation]]),
         );
         newlyAffectedOwnersIdentifier.add(ownerIdentifier);
       }
@@ -72,19 +78,18 @@ class RelayOperationTracker {
     }
 
     // But, if some owners were affected we need to add them to
-    // the `_pendingOperationsToOwnersIdentifier` set
-    const ownersAffectedByOperationIdentifier =
-      this._pendingOperationsToOwnersIdentifier.get(
-        pendingOperationIdentifier,
-      ) || new Set();
+    // the `_pendingOperationsToOwners` set
+    const ownersAffectedByPendingOperation =
+      this._pendingOperationsToOwners.get(pendingOperationIdentifier) ||
+      new Set();
 
     for (const ownerIdentifier of newlyAffectedOwnersIdentifier) {
       this._resolveOwnerResolvers(ownerIdentifier);
-      ownersAffectedByOperationIdentifier.add(ownerIdentifier);
+      ownersAffectedByPendingOperation.add(ownerIdentifier);
     }
-    this._pendingOperationsToOwnersIdentifier.set(
+    this._pendingOperationsToOwners.set(
       pendingOperationIdentifier,
-      ownersAffectedByOperationIdentifier,
+      ownersAffectedByPendingOperation,
     );
   }
 
@@ -94,7 +99,7 @@ class RelayOperationTracker {
    */
   complete(pendingOperation: RequestDescriptor): void {
     const pendingOperationIdentifier = pendingOperation.identifier;
-    const affectedOwnersIdentifier = this._pendingOperationsToOwnersIdentifier.get(
+    const affectedOwnersIdentifier = this._pendingOperationsToOwners.get(
       pendingOperationIdentifier,
     );
     if (affectedOwnersIdentifier == null) {
@@ -107,9 +112,8 @@ class RelayOperationTracker {
     // and some other operations
     const updatedOwnersIdentifier = new Set();
     for (const ownerIdentifier of affectedOwnersIdentifier) {
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(
-        ownerIdentifier,
-      );
+      const pendingOperationsAffectingOwner =
+        this._ownersToPendingOperations.get(ownerIdentifier);
       if (!pendingOperationsAffectingOwner) {
         continue;
       }
@@ -124,7 +128,7 @@ class RelayOperationTracker {
     // Complete subscriptions for all owners, affected by `pendingOperationIdentifier`
     for (const ownerIdentifier of completedOwnersIdentifier) {
       this._resolveOwnerResolvers(ownerIdentifier);
-      this._ownersToPendingOperationsIdentifier.delete(ownerIdentifier);
+      this._ownersToPendingOperations.delete(ownerIdentifier);
     }
 
     // Update all ownerIdentifier that were updated by `pendingOperationIdentifier` but still
@@ -134,31 +138,38 @@ class RelayOperationTracker {
     }
 
     // Finally, remove pending operation identifier
-    this._pendingOperationsToOwnersIdentifier.delete(
-      pendingOperationIdentifier,
-    );
+    this._pendingOperationsToOwners.delete(pendingOperationIdentifier);
   }
 
   _resolveOwnerResolvers(ownerIdentifier: string): void {
-    const promiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);
+    const promiseEntry = this._ownersToPendingPromise.get(ownerIdentifier);
     if (promiseEntry != null) {
       promiseEntry.resolve();
     }
-    this._ownersIdentifierToPromise.delete(ownerIdentifier);
+    this._ownersToPendingPromise.delete(ownerIdentifier);
   }
 
-  getPromiseForPendingOperationsAffectingOwner(
-    owner: RequestDescriptor,
-  ): Promise<void> | null {
+  getPendingOperationsAffectingOwner(owner: RequestDescriptor): {|
+    promise: Promise<void>,
+    pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+  |} | null {
     const ownerIdentifier = owner.identifier;
-    if (!this._ownersToPendingOperationsIdentifier.has(ownerIdentifier)) {
+    const pendingOperationsForOwner =
+      this._ownersToPendingOperations.get(ownerIdentifier);
+    if (
+      pendingOperationsForOwner == null ||
+      pendingOperationsForOwner.size === 0
+    ) {
       return null;
     }
-    const cachedPromiseEntry = this._ownersIdentifierToPromise.get(
-      ownerIdentifier,
-    );
+
+    const cachedPromiseEntry =
+      this._ownersToPendingPromise.get(ownerIdentifier);
     if (cachedPromiseEntry != null) {
-      return cachedPromiseEntry.promise;
+      return {
+        promise: cachedPromiseEntry.promise,
+        pendingOperations: cachedPromiseEntry.pendingOperations,
+      };
     }
     let resolve;
     const promise = new Promise(r => {
@@ -169,8 +180,13 @@ class RelayOperationTracker {
       'RelayOperationTracker: Expected resolver to be defined. If you' +
         'are seeing this, it is likely a bug in Relay.',
     );
-    this._ownersIdentifierToPromise.set(ownerIdentifier, {promise, resolve});
-    return promise;
+    const pendingOperations = Array.from(pendingOperationsForOwner.values());
+    this._ownersToPendingPromise.set(ownerIdentifier, {
+      promise,
+      resolve,
+      pendingOperations,
+    });
+    return {promise, pendingOperations};
   }
 }
 

package/store/RelayOptimisticRecordSource.js.flow

@@ -12,8 +12,6 @@
 
 'use strict';
 
-const RelayRecordSource = require('./RelayRecordSource');
-
 import type {DataID} from '../util/RelayRuntimeTypes';
 import type {RecordState} from './RelayRecordState';
 import type {
@@ -22,6 +20,8 @@ import type {
   RecordSource,
 } from './RelayStoreTypes';
 
+const RelayRecordSource = require('./RelayRecordSource');
+
 const UNPUBLISH_RECORD_SENTINEL = Object.freeze({
   __UNPUBLISH_RECORD_SENTINEL: true,
 });

package/store/RelayPublishQueue.js.flow

@@ -12,20 +12,11 @@
 
 'use strict';
 
-const ErrorUtils = require('ErrorUtils');
-const RelayReader = require('./RelayReader');
-const RelayRecordSource = require('./RelayRecordSource');
-const RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
-const RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
-const RelayRecordSourceSelectorProxy = require('../mutations/RelayRecordSourceSelectorProxy');
-
-const invariant = require('invariant');
-const warning = require('warning');
-
 import type {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
 import type {Disposable} from '../util/RelayRuntimeTypes';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {
+  MutationParameters,
   OperationDescriptor,
   OptimisticUpdate,
   PublishQueue,
@@ -39,12 +30,23 @@ import type {
   StoreUpdater,
 } from './RelayStoreTypes';
 
-type PendingCommit = PendingRelayPayload | PendingRecordSource | PendingUpdater;
-type PendingRelayPayload = {|
+const RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');
+const RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
+const RelayRecordSourceSelectorProxy = require('../mutations/RelayRecordSourceSelectorProxy');
+const RelayReader = require('./RelayReader');
+const RelayRecordSource = require('./RelayRecordSource');
+const invariant = require('invariant');
+const warning = require('warning');
+
+type PendingCommit<TMutation: MutationParameters> =
+  | PendingRelayPayload<TMutation>
+  | PendingRecordSource
+  | PendingUpdater;
+type PendingRelayPayload<TMutation: MutationParameters> = {|
   +kind: 'payload',
   +operation: OperationDescriptor,
   +payload: RelayResponsePayload,
-  +updater: ?SelectorStoreUpdater,
+  +updater: ?SelectorStoreUpdater<TMutation['response']>,
 |};
 type PendingRecordSource = {|
   +kind: 'source',
@@ -55,6 +57,10 @@ type PendingUpdater = {|
   +updater: StoreUpdater,
 |};
 
+const applyWithGuard =
+  global?.ErrorUtils?.applyWithGuard ??
+  ((callback, context, args, onError, name) => callback.apply(context, args));
+
 /**
  * Coordinates the concurrent modification of a `Store` due to optimistic and
  * non-revertable client updates and server payloads:
@@ -76,12 +82,19 @@ class RelayPublishQueue implements PublishQueue {
   // updates performing a rebase.
   _pendingBackupRebase: boolean;
   // Payloads to apply or Sources to publish to the store with the next `run()`.
-  _pendingData: Set<PendingCommit>;
+  // $FlowFixMe[unclear-type] See explanation below.
+  _pendingData: Set<PendingCommit<any>>;
   // Optimistic updaters to add with the next `run()`.
-  _pendingOptimisticUpdates: Set<OptimisticUpdate>;
+  // $FlowFixMe[unclear-type] See explanation below.
+  _pendingOptimisticUpdates: Set<OptimisticUpdate<any>>;
   // Optimistic updaters that are already added and might be rerun in order to
   // rebase them.
-  _appliedOptimisticUpdates: Set<OptimisticUpdate>;
+  // $FlowFixMe[unclear-type] See explanation below.
+  _appliedOptimisticUpdates: Set<OptimisticUpdate<any>>;
+  // 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
   _gcHold: ?Disposable;
   _isRunning: ?boolean;
@@ -105,7 +118,9 @@ class RelayPublishQueue implements PublishQueue {
   /**
    * Schedule applying an optimistic updates on the next `run()`.
    */
-  applyUpdate(updater: OptimisticUpdate): void {
+  applyUpdate<TMutation: MutationParameters>(
+    updater: OptimisticUpdate<TMutation>,
+  ): void {
     invariant(
       !this._appliedOptimisticUpdates.has(updater) &&
         !this._pendingOptimisticUpdates.has(updater),
@@ -118,7 +133,9 @@ class RelayPublishQueue implements PublishQueue {
   /**
    * Schedule reverting an optimistic updates on the next `run()`.
    */
-  revertUpdate(updater: OptimisticUpdate): void {
+  revertUpdate<TMutation: MutationParameters>(
+    updater: OptimisticUpdate<TMutation>,
+  ): void {
     if (this._pendingOptimisticUpdates.has(updater)) {
       // Reverted before it was applied
       this._pendingOptimisticUpdates.delete(updater);
@@ -140,10 +157,10 @@ class RelayPublishQueue implements PublishQueue {
   /**
    * Schedule applying a payload to the store on the next `run()`.
    */
-  commitPayload(
+  commitPayload<TMutation: MutationParameters>(
     operation: OperationDescriptor,
     payload: RelayResponsePayload,
-    updater?: ?SelectorStoreUpdater,
+    updater?: ?SelectorStoreUpdater<TMutation['response']>,
   ): void {
     this._pendingBackupRebase = true;
     this._pendingData.add({
@@ -182,7 +199,20 @@ class RelayPublishQueue implements PublishQueue {
   run(
     sourceOperation?: OperationDescriptor,
   ): $ReadOnlyArray<RequestDescriptor> {
+    const runWillClearGcHold =
+      this._appliedOptimisticUpdates === 0 && !!this._gcHold;
+    const 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 (__DEV__) {
+      warning(
+        !runIsANoop,
+        'RelayPublishQueue.run was called, but the call would have been a noop.',
+      );
       warning(
         this._isRunning !== true,
         'A store update was detected within another store update. Please ' +
@@ -191,6 +221,14 @@ class RelayPublishQueue implements PublishQueue {
       );
       this._isRunning = true;
     }
+
+    if (runIsANoop) {
+      if (__DEV__) {
+        this._isRunning = false;
+      }
+      return [];
+    }
+
     if (this._pendingBackupRebase) {
       if (this._hasStoreSnapshot) {
         this._store.restore();
@@ -229,7 +267,9 @@ class RelayPublishQueue implements PublishQueue {
    * _publishSourceFromPayload will return a boolean indicating if the
    * publish caused the store to be globally invalidated.
    */
-  _publishSourceFromPayload(pendingPayload: PendingRelayPayload): boolean {
+  _publishSourceFromPayload<TMutation: MutationParameters>(
+    pendingPayload: PendingRelayPayload<TMutation>,
+  ): boolean {
     const {payload, operation, updater} = pendingPayload;
     const {source, fieldPayloads} = payload;
     const mutator = new RelayRecordSourceMutator(
@@ -267,7 +307,8 @@ class RelayPublishQueue implements PublishQueue {
       const selectorData = lookupSelector(source, selector);
       updater(recordSourceSelectorProxy, selectorData);
     }
-    const idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();
+    const idsMarkedForInvalidation =
+      recordSourceProxy.getIDsMarkedForInvalidation();
     this._store.publish(source, idsMarkedForInvalidation);
     return recordSourceProxy.isStoreMarkedForInvalidation();
   }
@@ -299,7 +340,7 @@ class RelayPublishQueue implements PublishQueue {
           mutator,
           this._getDataID,
         );
-        ErrorUtils.applyWithGuard(
+        applyWithGuard(
           updater,
           null,
           [recordSourceProxy],
@@ -308,7 +349,8 @@ class RelayPublishQueue implements PublishQueue {
         );
         invalidatedStore =
           invalidatedStore || recordSourceProxy.isStoreMarkedForInvalidation();
-        const idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();
+        const idsMarkedForInvalidation =
+          recordSourceProxy.getIDsMarkedForInvalidation();
 
         this._store.publish(sink, idsMarkedForInvalidation);
       }
@@ -331,10 +373,11 @@ class RelayPublishQueue implements PublishQueue {
       this._handlerProvider,
     );
 
-    const processUpdate = optimisticUpdate => {
+    // $FlowFixMe[unclear-type] see explanation above.
+    const processUpdate = (optimisticUpdate: OptimisticUpdate<any>) => {
       if (optimisticUpdate.storeUpdater) {
         const {storeUpdater} = optimisticUpdate;
-        ErrorUtils.applyWithGuard(
+        applyWithGuard(
           storeUpdater,
           null,
           [recordSourceProxy],
@@ -344,18 +387,20 @@ class RelayPublishQueue implements PublishQueue {
       } else {
         const {operation, payload, updater} = optimisticUpdate;
         const {source, fieldPayloads} = payload;
-        const recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(
-          mutator,
-          recordSourceProxy,
-          operation.fragment,
-        );
-        let selectorData;
         if (source) {
           recordSourceProxy.publishSource(source, fieldPayloads);
-          selectorData = lookupSelector(source, operation.fragment);
         }
         if (updater) {
-          ErrorUtils.applyWithGuard(
+          let selectorData;
+          if (source) {
+            selectorData = lookupSelector(source, operation.fragment);
+          }
+          const recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(
+            mutator,
+            recordSourceProxy,
+            operation.fragment,
+          );
+          applyWithGuard(
             updater,
             null,
             [recordSourceSelectorProxy, selectorData],