relay-runtime 12.0.0 → 13.0.0-rc.0

package/store/RelayModernOperationDescriptor.js.flow

@@ -12,26 +12,25 @@
 
 'use strict';
 
-const deepFreeze = require('../util/deepFreeze');
-const getRequestIdentifier = require('../util/getRequestIdentifier');
-
-const {getOperationVariables} = require('./RelayConcreteVariables');
-const {
-  createNormalizationSelector,
-  createReaderSelector,
-} = require('./RelayModernSelector');
-const {ROOT_ID} = require('./RelayStoreUtils');
-
 import type {ConcreteRequest} from '../util/RelayConcreteNode';
 import type {
   CacheConfig,
   DataID,
+  OperationType,
   Variables,
   VariablesOf,
-  OperationType,
 } from '../util/RelayRuntimeTypes';
 import type {OperationDescriptor, RequestDescriptor} from './RelayStoreTypes';
 
+const deepFreeze = require('../util/deepFreeze');
+const getRequestIdentifier = require('../util/getRequestIdentifier');
+const {getOperationVariables} = require('./RelayConcreteVariables');
+const {
+  createNormalizationSelector,
+  createReaderSelector,
+} = require('./RelayModernSelector');
+const {ROOT_ID} = require('./RelayStoreUtils');
+
 /**
  * Creates an instance of the `OperationDescriptor` type defined in
  * `RelayStoreTypes` given an operation and some variables. The input variables

package/store/RelayModernRecord.js.flow

@@ -12,25 +12,24 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const deepFreeze = require('../util/deepFreeze');
-const invariant = require('invariant');
-const warning = require('warning');
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
+import type {DataID} from '../util/RelayRuntimeTypes';
+import type {Record} from './RelayStoreTypes';
 
+const deepFreeze = require('../util/deepFreeze');
 const {isClientID} = require('./ClientID');
 const {
   ACTOR_IDENTIFIER_KEY,
   ID_KEY,
+  INVALIDATED_AT_KEY,
   REF_KEY,
   REFS_KEY,
-  TYPENAME_KEY,
-  INVALIDATED_AT_KEY,
   ROOT_ID,
+  TYPENAME_KEY,
 } = require('./RelayStoreUtils');
-
-import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
-import type {DataID} from '../util/RelayRuntimeTypes';
-import type {Record} from './RelayStoreTypes';
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+const warning = require('warning');
 
 /**
  * @public
@@ -174,10 +173,14 @@ function getLinkedRecordID(record: Record, storageKey: string): ?DataID {
   invariant(
     typeof link === 'object' && link && typeof link[REF_KEY] === 'string',
     'RelayModernRecord.getLinkedRecordID(): Expected `%s.%s` to be a linked ID, ' +
-      'was `%s`.',
+      'was `%s`.%s',
     record[ID_KEY],
     storageKey,
     JSON.stringify(link),
+    typeof link === 'object' && link[REFS_KEY] !== undefined
+      ? ' It appears to be a plural linked record: did you mean to call ' +
+          'getLinkedRecords() instead of getLinkedRecord()?'
+      : '',
   );
   return link[REF_KEY];
 }
@@ -199,10 +202,14 @@ function getLinkedRecordIDs(
   invariant(
     typeof links === 'object' && Array.isArray(links[REFS_KEY]),
     'RelayModernRecord.getLinkedRecordIDs(): Expected `%s.%s` to contain an array ' +
-      'of linked IDs, got `%s`.',
+      'of linked IDs, got `%s`.%s',
     record[ID_KEY],
     storageKey,
     JSON.stringify(links),
+    typeof links === 'object' && links[REF_KEY] !== undefined
+      ? ' It appears to be a singular linked record: did you mean to call ' +
+          'getLinkedRecord() instead of getLinkedRecords()?'
+      : '',
   );
   // assume items of the array are ids
   return (links[REFS_KEY]: any);

package/store/RelayModernSelector.js.flow

@@ -12,22 +12,11 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-const warning = require('warning');
-
-const {getFragmentVariables} = require('./RelayConcreteVariables');
-const {
-  FRAGMENT_OWNER_KEY,
-  FRAGMENTS_KEY,
-  ID_KEY,
-  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
-} = require('./RelayStoreUtils');
-
 import type {NormalizationSelectableNode} from '../util/NormalizationNode';
 import type {ReaderFragment} from '../util/ReaderNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
+  ClientEdgeTraversalPath,
   NormalizationSelector,
   PluralReaderSelector,
   ReaderSelector,
@@ -35,6 +24,18 @@ import type {
   SingularReaderSelector,
 } from './RelayStoreTypes';
 
+const {getFragmentVariables} = require('./RelayConcreteVariables');
+const {
+  CLIENT_EDGE_TRAVERSAL_PATH,
+  FRAGMENT_OWNER_KEY,
+  FRAGMENTS_KEY,
+  ID_KEY,
+  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
+} = require('./RelayStoreUtils');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+const warning = require('warning');
+
 /**
  * @public
  *
@@ -80,6 +81,7 @@ function getSingularSelector(
   const mixedOwner = item[FRAGMENT_OWNER_KEY];
   const isWithinUnmatchedTypeRefinement =
     item[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] === true;
+  const mixedClientEdgeTraversalPath = item[CLIENT_EDGE_TRAVERSAL_PATH];
   if (
     typeof dataID === 'string' &&
     typeof fragments === 'object' &&
@@ -87,22 +89,28 @@ function getSingularSelector(
     typeof fragments[fragment.name] === 'object' &&
     fragments[fragment.name] !== null &&
     typeof mixedOwner === 'object' &&
-    mixedOwner !== null
+    mixedOwner !== null &&
+    (mixedClientEdgeTraversalPath == null ||
+      Array.isArray(mixedClientEdgeTraversalPath))
   ) {
     const owner: RequestDescriptor = (mixedOwner: $FlowFixMe);
-    const argumentVariables = fragments[fragment.name];
+    const clientEdgeTraversalPath: ?ClientEdgeTraversalPath =
+      (mixedClientEdgeTraversalPath: $FlowFixMe);
 
+    const argumentVariables = fragments[fragment.name];
     const fragmentVariables = getFragmentVariables(
       fragment,
       owner.variables,
       argumentVariables,
     );
+
     return createReaderSelector(
       fragment,
       dataID,
       fragmentVariables,
       owner,
       isWithinUnmatchedTypeRefinement,
+      clientEdgeTraversalPath,
     );
   }
 
@@ -419,11 +427,13 @@ function createReaderSelector(
   variables: Variables,
   request: RequestDescriptor,
   isWithinUnmatchedTypeRefinement: boolean = false,
+  clientEdgeTraversalPath: ?ClientEdgeTraversalPath,
 ): SingularReaderSelector {
   return {
     kind: 'SingularReaderSelector',
     dataID,
     isWithinUnmatchedTypeRefinement,
+    clientEdgeTraversalPath: clientEdgeTraversalPath ?? null,
     node: fragment,
     variables,
     owner: request,

package/store/RelayModernStore.js.flow

@@ -12,34 +12,13 @@
 
 'use strict';
 
-const DataChecker = require('./DataChecker');
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayModernRecord = require('./RelayModernRecord');
-const RelayOptimisticRecordSource = require('./RelayOptimisticRecordSource');
-const RelayReader = require('./RelayReader');
-const RelayReferenceMarker = require('./RelayReferenceMarker');
-const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
-const RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
-const RelayStoreUtils = require('./RelayStoreUtils');
-
-const deepFreeze = require('../util/deepFreeze');
-const defaultGetDataID = require('./defaultGetDataID');
-const invariant = require('invariant');
-const resolveImmediate = require('../util/resolveImmediate');
-
-const {
-  INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
-  assertInternalActorIndentifier,
-} = require('../multi-actor-environment/ActorIdentifier');
-const {ROOT_ID, ROOT_TYPE} = require('./RelayStoreUtils');
-const {RecordResolverCache} = require('./ResolverCache');
-
 import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {DataID, Disposable} from '../util/RelayRuntimeTypes';
 import type {Availability} from './DataChecker';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {
   CheckOptions,
+  DataIDSet,
   LogFunction,
   MutableRecordSource,
   OperationAvailability,
@@ -52,10 +31,29 @@ import type {
   Snapshot,
   Store,
   StoreSubscriptions,
-  DataIDSet,
 } from './RelayStoreTypes';
 import type {ResolverCache} from './ResolverCache';
 
+const {
+  INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+  assertInternalActorIndentifier,
+} = require('../multi-actor-environment/ActorIdentifier');
+const deepFreeze = require('../util/deepFreeze');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const resolveImmediate = require('../util/resolveImmediate');
+const DataChecker = require('./DataChecker');
+const defaultGetDataID = require('./defaultGetDataID');
+const RelayModernRecord = require('./RelayModernRecord');
+const RelayOptimisticRecordSource = require('./RelayOptimisticRecordSource');
+const RelayReader = require('./RelayReader');
+const RelayReferenceMarker = require('./RelayReferenceMarker');
+const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
+const RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
+const RelayStoreUtils = require('./RelayStoreUtils');
+const {ROOT_ID, ROOT_TYPE} = require('./RelayStoreUtils');
+const {RecordResolverCache} = require('./ResolverCache');
+const invariant = require('invariant');
+
 export opaque type InvalidationState = {|
   dataIDs: $ReadOnlyArray<DataID>,
   invalidations: Map<DataID, ?number>,
@@ -715,7 +713,6 @@ function updateTargetFromSource(
         currentWriteEpoch,
       );
       invalidatedRecordIDs.add(dataID);
-      // $FlowFixMe[incompatible-call]
       target.set(dataID, nextRecord);
     });
   }

package/store/RelayOperationTracker.js.flow

@@ -12,10 +12,10 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
 import type {RequestDescriptor} from './RelayStoreTypes';
 
+const invariant = require('invariant');
+
 class RelayOperationTracker {
   _ownersToPendingOperations: Map<string, Map<string, RequestDescriptor>>;
   _pendingOperationsToOwners: Map<string, Set<string>>;
@@ -49,9 +49,8 @@ class RelayOperationTracker {
     const newlyAffectedOwnersIdentifier = new Set();
     for (const owner of affectedOwners) {
       const ownerIdentifier = owner.identifier;
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperations.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
@@ -113,9 +112,8 @@ class RelayOperationTracker {
     // and some other operations
     const updatedOwnersIdentifier = new Set();
     for (const ownerIdentifier of affectedOwnersIdentifier) {
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperations.get(
-        ownerIdentifier,
-      );
+      const pendingOperationsAffectingOwner =
+        this._ownersToPendingOperations.get(ownerIdentifier);
       if (!pendingOperationsAffectingOwner) {
         continue;
       }
@@ -151,16 +149,13 @@ class RelayOperationTracker {
     this._ownersToPendingPromise.delete(ownerIdentifier);
   }
 
-  getPendingOperationsAffectingOwner(
-    owner: RequestDescriptor,
-  ): {|
+  getPendingOperationsAffectingOwner(owner: RequestDescriptor): {|
     promise: Promise<void>,
     pendingOperations: $ReadOnlyArray<RequestDescriptor>,
   |} | null {
     const ownerIdentifier = owner.identifier;
-    const pendingOperationsForOwner = this._ownersToPendingOperations.get(
-      ownerIdentifier,
-    );
+    const pendingOperationsForOwner =
+      this._ownersToPendingOperations.get(ownerIdentifier);
     if (
       pendingOperationsForOwner == null ||
       pendingOperationsForOwner.size === 0
@@ -168,9 +163,8 @@ class RelayOperationTracker {
       return null;
     }
 
-    const cachedPromiseEntry = this._ownersToPendingPromise.get(
-      ownerIdentifier,
-    );
+    const cachedPromiseEntry =
+      this._ownersToPendingPromise.get(ownerIdentifier);
     if (cachedPromiseEntry != null) {
       return {
         promise: cachedPromiseEntry.promise,

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,19 +12,11 @@
 
 'use strict';
 
-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,
@@ -38,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',
@@ -79,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;
@@ -108,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),
@@ -121,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);
@@ -143,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({
@@ -253,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(
@@ -291,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();
   }
@@ -332,7 +349,8 @@ class RelayPublishQueue implements PublishQueue {
         );
         invalidatedStore =
           invalidatedStore || recordSourceProxy.isStoreMarkedForInvalidation();
-        const idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();
+        const idsMarkedForInvalidation =
+          recordSourceProxy.getIDsMarkedForInvalidation();
 
         this._store.publish(sink, idsMarkedForInvalidation);
       }
@@ -355,7 +373,8 @@ 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;
         applyWithGuard(