relay-runtime 0.0.0-main-a2087736 → 0.0.0-main-16753a5d

package/store/RelayPublishQueue.js.flow

@@ -16,6 +16,7 @@ import type {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
 import type {Disposable} from '../util/RelayRuntimeTypes';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {
+  MutationParameters,
   OperationDescriptor,
   OptimisticUpdate,
   PublishQueue,
@@ -37,12 +38,15 @@ const RelayRecordSource = require('./RelayRecordSource');
 const invariant = require('invariant');
 const warning = require('warning');
 
-type PendingCommit = PendingRelayPayload | PendingRecordSource | PendingUpdater;
-type PendingRelayPayload = {|
+type PendingCommit<TMutation: MutationParameters> =
+  | PendingRelayPayload<TMutation>
+  | PendingRecordSource
+  | PendingUpdater;
+type PendingRelayPayload<TMutation: MutationParameters> = {|
   +kind: 'payload',
   +operation: OperationDescriptor,
   +payload: RelayResponsePayload,
-  +updater: ?SelectorStoreUpdater,
+  +updater: ?SelectorStoreUpdater<$ElementType<TMutation, 'response'>>,
 |};
 type PendingRecordSource = {|
   +kind: 'source',
@@ -78,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;
@@ -107,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),
@@ -120,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);
@@ -142,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<$ElementType<TMutation, 'response'>>,
   ): void {
     this._pendingBackupRebase = true;
     this._pendingData.add({
@@ -252,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(
@@ -354,7 +371,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(

package/store/RelayStoreTypes.js.flow

@@ -673,7 +673,9 @@ export interface IEnvironment {
    * Apply an optimistic mutation response and/or updater. The mutation can be
    * reverted by calling `dispose()` on the returned value.
    */
-  applyMutation(optimisticConfig: OptimisticResponseConfig): Disposable;
+  applyMutation<TMutation: MutationParameters>(
+    optimisticConfig: OptimisticResponseConfig<TMutation>,
+  ): Disposable;
 
   /**
    * Commit an updater to the environment. This mutation cannot be reverted and
@@ -740,9 +742,9 @@ export interface IEnvironment {
    * Note: Observables are lazy, so calling this method will do nothing until
    * the result is subscribed to: environment.executeSubscription({...}).subscribe({...}).
    */
-  executeSubscription(config: {|
+  executeSubscription<TMutation: MutationParameters>(config: {|
     operation: OperationDescriptor,
-    updater?: ?SelectorStoreUpdater,
+    updater?: ?SelectorStoreUpdater<$ElementType<TMutation, 'response'>>,
   |}): RelayObservable<GraphQLResponse>;
 
   /**
@@ -755,8 +757,8 @@ export interface IEnvironment {
    * the result is subscribed to:
    * environment.executeMutation({...}).subscribe({...}).
    */
-  executeMutation(
-    config: ExecuteMutationConfig,
+  executeMutation<TMutation: MutationParameters>(
+    config: ExecuteMutationConfig<TMutation>,
   ): RelayObservable<GraphQLResponse>;
 
   /**
@@ -972,35 +974,33 @@ export type StoreUpdater = (store: RecordSourceProxy) => void;
  * order to easily access the root fields of a query/mutation as well as a
  * second argument of the response object of the mutation.
  */
-export type SelectorStoreUpdater = (
+export type SelectorStoreUpdater<-TMutationResponse> = (
   store: RecordSourceSelectorProxy,
-  // Actually SelectorData, but mixed is inconvenient to access deeply in
-  // product code.
-  data: $FlowFixMe,
+  data: ?TMutationResponse,
 ) => void;
 
 /**
  * A set of configs that can be used to apply an optimistic update into the
  * store.
  */
-export type OptimisticUpdate =
+export type OptimisticUpdate<TMutation: MutationParameters> =
   | OptimisticUpdateFunction
-  | OptimisticUpdateRelayPayload;
+  | OptimisticUpdateRelayPayload<TMutation>;
 
 export type OptimisticUpdateFunction = {|
   +storeUpdater: StoreUpdater,
 |};
 
-export type OptimisticUpdateRelayPayload = {|
+export type OptimisticUpdateRelayPayload<TMutation: MutationParameters> = {|
   +operation: OperationDescriptor,
   +payload: RelayResponsePayload,
-  +updater: ?SelectorStoreUpdater,
+  +updater: ?SelectorStoreUpdater<$ElementType<TMutation, 'response'>>,
 |};
 
-export type OptimisticResponseConfig = {|
+export type OptimisticResponseConfig<TMutation: MutationParameters> = {|
   +operation: OperationDescriptor,
   +response: ?PayloadData,
-  +updater: ?SelectorStoreUpdater,
+  +updater: ?SelectorStoreUpdater<$ElementType<TMutation, 'response'>>,
 |};
 
 /**
@@ -1068,11 +1068,13 @@ export type RelayResponsePayload = {|
 /**
  * Configuration on the executeMutation(...).
  */
-export type ExecuteMutationConfig = {|
+export type ExecuteMutationConfig<TMutation: MutationParameters> = {|
   operation: OperationDescriptor,
-  optimisticUpdater?: ?SelectorStoreUpdater,
+  optimisticUpdater?: ?SelectorStoreUpdater<
+    $ElementType<TMutation, 'response'>,
+  >,
   optimisticResponse?: ?Object,
-  updater?: ?SelectorStoreUpdater,
+  updater?: ?SelectorStoreUpdater<$ElementType<TMutation, 'response'>>,
   uploadables?: ?UploadableMap,
 |};
 
@@ -1083,12 +1085,16 @@ export interface PublishQueue {
   /**
    * Schedule applying an optimistic updates on the next `run()`.
    */
-  applyUpdate(updater: OptimisticUpdate): void;
+  applyUpdate<TMutation: MutationParameters>(
+    updater: OptimisticUpdate<TMutation>,
+  ): void;
 
   /**
    * Schedule reverting an optimistic updates on the next `run()`.
    */
-  revertUpdate(updater: OptimisticUpdate): void;
+  revertUpdate<TMutation: MutationParameters>(
+    updater: OptimisticUpdate<TMutation>,
+  ): void;
 
   /**
    * Schedule a revert of all optimistic updates on the next `run()`.
@@ -1098,10 +1104,10 @@ export interface PublishQueue {
   /**
    * Schedule applying a payload to the store on the next `run()`.
    */
-  commitPayload(
+  commitPayload<TMutation: MutationParameters>(
     operation: OperationDescriptor,
     payload: RelayResponsePayload,
-    updater?: ?SelectorStoreUpdater,
+    updater?: ?SelectorStoreUpdater<$ElementType<TMutation, 'response'>>,
   ): void;
 
   /**

package/subscription/requestSubscription.js.flow

@@ -47,7 +47,7 @@ export type GraphQLSubscriptionConfig<T: SubscriptionParameters> = {|
   onCompleted?: ?() => void,
   onError?: ?(error: Error) => void,
   onNext?: ?(response: ?$ElementType<T, 'response'>) => void,
-  updater?: ?SelectorStoreUpdater,
+  updater?: ?SelectorStoreUpdater<$ElementType<T, 'response'>>,
 |};
 
 export type DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
@@ -58,7 +58,7 @@ export type DEPRECATED_GraphQLSubscriptionConfig<TSubscriptionPayload> = {|
   onCompleted?: ?() => void,
   onError?: ?(error: Error) => void,
   onNext?: ?(response: ?TSubscriptionPayload) => void,
-  updater?: ?SelectorStoreUpdater,
+  updater?: ?SelectorStoreUpdater<TSubscriptionPayload>,
 |};
 
 function requestSubscription<TSubscriptionPayload>(