relay-runtime 12.0.0 → 13.0.0-rc.0

package/multi-actor-environment/MultiActorEnvironment.js.flow

@@ -11,16 +11,6 @@
 
 'use strict';
 
-const ActorSpecificEnvironment = require('./ActorSpecificEnvironment');
-const OperationExecutor = require('../store/OperationExecutor');
-const RelayDefaultHandlerProvider = require('../handlers/RelayDefaultHandlerProvider');
-const RelayModernStore = require('../store/RelayModernStore');
-const RelayObservable = require('../network/RelayObservable');
-const RelayRecordSource = require('../store/RelayRecordSource');
-
-const defaultGetDataID = require('../store/defaultGetDataID');
-const defaultRequiredFieldLogger = require('../store/defaultRequiredFieldLogger');
-
 import type {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
 import type {GraphQLResponse, PayloadData} from '../network/RelayNetworkTypes';
 import type {INetwork} from '../network/RelayNetworkTypes';
@@ -31,6 +21,7 @@ import type {
   LogFunction,
   MissingFieldHandler,
   MutableRecordSource,
+  MutationParameters,
   OperationAvailability,
   OperationDescriptor,
   OperationLoader,
@@ -54,6 +45,15 @@ import type {
   MultiActorStoreUpdater,
 } from './MultiActorEnvironmentTypes';
 
+const RelayDefaultHandlerProvider = require('../handlers/RelayDefaultHandlerProvider');
+const RelayObservable = require('../network/RelayObservable');
+const defaultGetDataID = require('../store/defaultGetDataID');
+const defaultRequiredFieldLogger = require('../store/defaultRequiredFieldLogger');
+const OperationExecutor = require('../store/OperationExecutor');
+const RelayModernStore = require('../store/RelayModernStore');
+const RelayRecordSource = require('../store/RelayRecordSource');
+const ActorSpecificEnvironment = require('./ActorSpecificEnvironment');
+
 export type MultiActorEnvironmentConfig = $ReadOnly<{
   createConfigNameForActor?: ?(actorIdentifier: ActorIdentifier) => string,
   createNetworkForActor: (actorIdentifier: ActorIdentifier) => INetwork,
@@ -161,9 +161,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
         handlers: [],
         defaultActorIdentifier: actorEnvironment.actorIdentifier,
         getSourceForActor: actorIdentifier => {
-          return this.forActor(actorIdentifier)
-            .getStore()
-            .getSource();
+          return this.forActor(actorIdentifier).getStore().getSource();
         },
         getTargetForActor: () => {
           return RelayRecordSource.create();
@@ -189,9 +187,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
       handlers,
       defaultActorIdentifier: actorEnvironment.actorIdentifier,
       getSourceForActor: actorIdentifier => {
-        return this.forActor(actorIdentifier)
-          .getStore()
-          .getSource();
+        return this.forActor(actorIdentifier).getStore().getSource();
       },
       getTargetForActor: actorIdentifier => {
         let target = targets.get(actorIdentifier);
@@ -274,9 +270,9 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     });
   }
 
-  applyMutation(
+  applyMutation<TMutation: MutationParameters>(
     actorEnvironment: IActorEnvironment,
-    optimisticConfig: OptimisticResponseConfig,
+    optimisticConfig: OptimisticResponseConfig<TMutation>,
   ): Disposable {
     const subscription = this._execute(actorEnvironment, {
       createSource: () => RelayObservable.create(_sink => {}),
@@ -324,13 +320,38 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
   }
 
   execute(
+    actorEnvironment: IActorEnvironment,
+    {
+      operation,
+    }: {
+      operation: OperationDescriptor,
+    },
+  ): RelayObservable<GraphQLResponse> {
+    return this._execute(actorEnvironment, {
+      createSource: () =>
+        actorEnvironment
+          .getNetwork()
+          .execute(
+            operation.request.node.params,
+            operation.request.variables,
+            operation.request.cacheConfig || {},
+            null,
+          ),
+      isClientPayload: false,
+      operation,
+      optimisticConfig: null,
+      updater: null,
+    });
+  }
+
+  executeSubscription<TMutation: MutationParameters>(
     actorEnvironment: IActorEnvironment,
     {
       operation,
       updater,
     }: {
       operation: OperationDescriptor,
-      updater?: ?SelectorStoreUpdater,
+      updater?: ?SelectorStoreUpdater<TMutation['response']>,
     },
   ): RelayObservable<GraphQLResponse> {
     return this._execute(actorEnvironment, {
@@ -350,7 +371,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     });
   }
 
-  executeMutation(
+  executeMutation<TMutation: MutationParameters>(
     actorEnvironment: IActorEnvironment,
     {
       operation,
@@ -358,7 +379,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
       optimisticUpdater,
       updater,
       uploadables,
-    }: ExecuteMutationConfig,
+    }: ExecuteMutationConfig<TMutation>,
   ): RelayObservable<GraphQLResponse> {
     let optimisticConfig;
     if (optimisticResponse || optimisticUpdater) {
@@ -414,7 +435,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     return this._isServer;
   }
 
-  _execute(
+  _execute<TMutation: MutationParameters>(
     actorEnvironment: IActorEnvironment,
     {
       createSource,
@@ -426,8 +447,8 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
       createSource: () => RelayObservable<GraphQLResponse>,
       isClientPayload: boolean,
       operation: OperationDescriptor,
-      optimisticConfig: ?OptimisticResponseConfig,
-      updater: ?SelectorStoreUpdater,
+      optimisticConfig: ?OptimisticResponseConfig<TMutation>,
+      updater: ?SelectorStoreUpdater<TMutation['response']>,
     |},
   ): RelayObservable<GraphQLResponse> {
     return RelayObservable.create(sink => {

package/multi-actor-environment/MultiActorEnvironmentTypes.js.flow

@@ -11,21 +11,22 @@
 
 'use strict';
 
-import type {PayloadData, GraphQLResponse} from '../network/RelayNetworkTypes';
+import type {GraphQLResponse, PayloadData} from '../network/RelayNetworkTypes';
 import type RelayObservable from '../network/RelayObservable';
 import type RelayPublishQueue from '../store/RelayPublishQueue';
 import type {
+  ExecuteMutationConfig,
+  IEnvironment,
+  MutationParameters,
   OperationAvailability,
   OperationDescriptor,
   OptimisticResponseConfig,
   OptimisticUpdateFunction,
+  RecordSourceProxy,
   SelectorStoreUpdater,
   SingularReaderSelector,
   Snapshot,
   StoreUpdater,
-  IEnvironment,
-  ExecuteMutationConfig,
-  RecordSourceProxy,
 } from '../store/RelayStoreTypes';
 import type {Disposable} from '../util/RelayRuntimeTypes';
 import type {ActorIdentifier} from './ActorIdentifier';
@@ -138,9 +139,9 @@ export interface IMultiActorEnvironment {
    * Apply an optimistic mutation response and/or updater. The mutation can be
    * reverted by calling `dispose()` on the returned value.
    */
-  applyMutation(
+  applyMutation<TMutation: MutationParameters>(
     actorEnvironment: IActorEnvironment,
-    optimisticConfig: OptimisticResponseConfig,
+    optimisticConfig: OptimisticResponseConfig<TMutation>,
   ): Disposable;
 
   /**
@@ -180,17 +181,32 @@ export interface IMultiActorEnvironment {
    * responses may be returned (via `next`) over time followed by either
    * the request completing (`completed`) or an error (`error`).
    *
+   * Note: Observables are lazy, so calling this method will do nothing until
+   * the result is subscribed to: environment.execute({...}).subscribe({...}).
+   */
+  execute(
+    actorEnvironment: IActorEnvironment,
+    config: {
+      operation: OperationDescriptor,
+    },
+  ): RelayObservable<GraphQLResponse>;
+
+  /**
+   * Send a subscription to the server with Observer semantics: one or more
+   * responses may be returned (via `next`) over time followed by either
+   * the request completing (`completed`) or an error (`error`).
+   *
    * Networks/servers that support subscriptions may choose to hold the
    * subscription open indefinitely such that `complete` is not called.
    *
    * Note: Observables are lazy, so calling this method will do nothing until
-   * the result is subscribed to: environment.execute({...}).subscribe({...}).
+   * the result is subscribed to: environment.executeSubscription({...}).subscribe({...}).
    */
-  execute(
+  executeSubscription<TMutation: MutationParameters>(
     actorEnvironment: IActorEnvironment,
     config: {
       operation: OperationDescriptor,
-      updater?: ?SelectorStoreUpdater,
+      updater?: ?SelectorStoreUpdater<TMutation['response']>,
     },
   ): RelayObservable<GraphQLResponse>;
 
@@ -204,9 +220,9 @@ export interface IMultiActorEnvironment {
    * the result is subscribed to:
    * environment.executeMutation({...}).subscribe({...}).
    */
-  executeMutation(
+  executeMutation<TMutation: MutationParameters>(
     actorEnvironment: IActorEnvironment,
-    config: ExecuteMutationConfig,
+    config: ExecuteMutationConfig<TMutation>,
   ): RelayObservable<GraphQLResponse>;
 
   /**

package/multi-actor-environment/index.js.flow

@@ -11,9 +11,8 @@
 
 'use strict';
 
-const MultiActorEnvironment = require('./MultiActorEnvironment');
-
 const {getActorIdentifier} = require('./ActorIdentifier');
+const MultiActorEnvironment = require('./MultiActorEnvironment');
 
 export type {ActorIdentifier} from './ActorIdentifier';
 export type {

package/mutations/RelayDeclarativeMutationConfig.js.flow

@@ -12,11 +12,8 @@
 
 'use strict';
 
-const ConnectionHandler = require('../handlers/connection/ConnectionHandler');
-
-const warning = require('warning');
-
 import type {
+  MutationParameters,
   RecordSourceSelectorProxy,
   SelectorData,
   SelectorStoreUpdater,
@@ -24,6 +21,9 @@ import type {
 import type {ConcreteRequest} from '../util/RelayConcreteNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
+const ConnectionHandler = require('../handlers/connection/ConnectionHandler');
+const warning = require('warning');
+
 const MutationTypes = Object.freeze({
   RANGE_ADD: 'RANGE_ADD',
   RANGE_DELETE: 'RANGE_DELETE',
@@ -39,7 +39,7 @@ export type RangeOperation = $Values<typeof RangeOperations>;
 
 type RangeBehaviorsFunction = (connectionArgs: {
   [name: string]: $FlowFixMe,
-  ...,
+  ...
 }) => RangeOperation;
 type RangeBehaviorsObject = {[key: string]: RangeOperation, ...};
 export type RangeBehaviors = RangeBehaviorsFunction | RangeBehaviorsObject;
@@ -84,18 +84,21 @@ export type DeclarativeMutationConfig =
   | RangeDeleteConfig
   | NodeDeleteConfig;
 
-function convert(
+function convert<TMutation: MutationParameters>(
   configs: Array<DeclarativeMutationConfig>,
   request: ConcreteRequest,
-  optimisticUpdater?: ?SelectorStoreUpdater,
-  updater?: ?SelectorStoreUpdater,
+  optimisticUpdater?: ?SelectorStoreUpdater<TMutation['response']>,
+  updater?: ?SelectorStoreUpdater<TMutation['response']>,
 ): {
-  optimisticUpdater: SelectorStoreUpdater,
-  updater: SelectorStoreUpdater,
+  optimisticUpdater: SelectorStoreUpdater<TMutation['response']>,
+  updater: SelectorStoreUpdater<TMutation['response']>,
   ...
 } {
-  const configOptimisticUpdates = optimisticUpdater ? [optimisticUpdater] : [];
-  const configUpdates = updater ? [updater] : [];
+  const configOptimisticUpdates: Array<
+    SelectorStoreUpdater<TMutation['response']>,
+  > = optimisticUpdater ? [optimisticUpdater] : [];
+  const configUpdates: Array<SelectorStoreUpdater<TMutation['response']>> =
+    updater ? [updater] : [];
   configs.forEach(config => {
     switch (config.type) {
       case 'NODE_DELETE':
@@ -124,13 +127,16 @@ function convert(
   return {
     optimisticUpdater: (
       store: RecordSourceSelectorProxy,
-      data: ?SelectorData,
+      data: ?TMutation['response'],
     ) => {
       configOptimisticUpdates.forEach(eachOptimisticUpdater => {
         eachOptimisticUpdater(store, data);
       });
     },
-    updater: (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    updater: (
+      store: RecordSourceSelectorProxy,
+      data: ?TMutation['response'],
+    ) => {
       configUpdates.forEach(eachUpdater => {
         eachUpdater(store, data);
       });
@@ -141,13 +147,13 @@ function convert(
 function nodeDelete(
   config: NodeDeleteConfig,
   request: ConcreteRequest,
-): ?SelectorStoreUpdater {
+): ?SelectorStoreUpdater<mixed> {
   const {deletedIDFieldName} = config;
   const rootField = getRootField(request);
   if (!rootField) {
     return null;
   }
-  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+  return (store: RecordSourceSelectorProxy, data: ?mixed) => {
     const payload = store.getRootField(rootField);
     if (!payload) {
       return;
@@ -165,7 +171,7 @@ function nodeDelete(
 function rangeAdd(
   config: RangeAddConfig,
   request: ConcreteRequest,
-): ?SelectorStoreUpdater {
+): ?SelectorStoreUpdater<mixed> {
   const {parentID, connectionInfo, edgeName} = config;
   if (!parentID) {
     warning(
@@ -179,7 +185,7 @@ function rangeAdd(
   if (!connectionInfo || !rootField) {
     return null;
   }
-  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+  return (store: RecordSourceSelectorProxy, data: ?mixed) => {
     const parent = store.get(parentID);
     if (!parent) {
       return;
@@ -233,13 +239,9 @@ function rangeAdd(
 function rangeDelete(
   config: RangeDeleteConfig,
   request: ConcreteRequest,
-): ?SelectorStoreUpdater {
-  const {
-    parentID,
-    connectionKeys,
-    pathToConnection,
-    deletedIDFieldName,
-  } = config;
+): ?SelectorStoreUpdater<mixed> {
+  const {parentID, connectionKeys, pathToConnection, deletedIDFieldName} =
+    config;
   if (!parentID) {
     warning(
       false,
@@ -252,12 +254,16 @@ function rangeDelete(
   if (!rootField) {
     return null;
   }
-  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+  return (store: RecordSourceSelectorProxy, data: ?mixed) => {
     if (!data) {
       return;
     }
     const deleteIDs = [];
+    // the type of data should come from a type parameter associated with ConcreteRequest,
+    // but ConcreteRequest does not contain a type parameter. Hence, we use a FlowFixMe.
+    // $FlowFixMe[incompatible-use] see above
     let deletedIDField = data[rootField];
+
     if (deletedIDField && Array.isArray(deletedIDFieldName)) {
       for (const eachField of deletedIDFieldName) {
         if (deletedIDField && typeof deletedIDField === 'object') {

package/mutations/RelayRecordProxy.js.flow

@@ -12,17 +12,16 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
-const {generateClientID} = require('../store/ClientID');
-const {getStableStorageKey} = require('../store/RelayStoreUtils');
-
 import type {RecordProxy} from '../store/RelayStoreTypes';
 import type {Arguments} from '../store/RelayStoreUtils';
 import type {DataID} from '../util/RelayRuntimeTypes';
 import type RelayRecordSourceMutator from './RelayRecordSourceMutator';
 import type RelayRecordSourceProxy from './RelayRecordSourceProxy';
 
+const {generateClientID} = require('../store/ClientID');
+const {getStableStorageKey} = require('../store/RelayStoreUtils');
+const invariant = require('invariant');
+
 /**
  * @internal
  *

package/mutations/RelayRecordSourceMutator.js.flow

@@ -12,12 +12,6 @@
 
 'use strict';
 
-const RelayModernRecord = require('../store/RelayModernRecord');
-
-const invariant = require('invariant');
-
-const {EXISTENT} = require('../store/RelayRecordState');
-
 import type {RecordState} from '../store/RelayRecordState';
 import type {
   MutableRecordSource,
@@ -26,6 +20,10 @@ import type {
 } from '../store/RelayStoreTypes';
 import type {DataID} from '../util/RelayRuntimeTypes';
 
+const RelayModernRecord = require('../store/RelayModernRecord');
+const {EXISTENT} = require('../store/RelayRecordState');
+const invariant = require('invariant');
+
 /**
  * @internal
  *

package/mutations/RelayRecordSourceProxy.js.flow

@@ -12,26 +12,28 @@
 
 'use strict';
 
-const RelayModernRecord = require('../store/RelayModernRecord');
-const RelayRecordProxy = require('./RelayRecordProxy');
-
-const invariant = require('invariant');
-
-const {EXISTENT, NONEXISTENT} = require('../store/RelayRecordState');
-const {ROOT_ID, ROOT_TYPE} = require('../store/RelayStoreUtils');
-
 import type {HandlerProvider} from '../handlers/RelayDefaultHandlerProvider';
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
 import type {GetDataID} from '../store/RelayResponseNormalizer';
 import type {
   DataIDSet,
   HandleFieldPayload,
-  RecordSource,
   RecordProxy,
+  RecordSource,
   RecordSourceProxy,
 } from '../store/RelayStoreTypes';
-import type {DataID} from '../util/RelayRuntimeTypes';
+import type {DataID, OperationType} from '../util/RelayRuntimeTypes';
 import type RelayRecordSourceMutator from './RelayRecordSourceMutator';
 
+const RelayModernRecord = require('../store/RelayModernRecord');
+const {EXISTENT, NONEXISTENT} = require('../store/RelayRecordState');
+const {ROOT_ID, ROOT_TYPE} = require('../store/RelayStoreUtils');
+const {
+  readUpdatableQuery_EXPERIMENTAL,
+} = require('./readUpdatableQuery_EXPERIMENTAL');
+const RelayRecordProxy = require('./RelayRecordProxy');
+const invariant = require('invariant');
+
 /**
  * @internal
  *
@@ -160,6 +162,13 @@ class RelayRecordSourceProxy implements RecordSourceProxy {
   getIDsMarkedForInvalidation(): DataIDSet {
     return this._idsMarkedForInvalidation;
   }
+
+  readUpdatableQuery_EXPERIMENTAL<TQuery: OperationType>(
+    query: GraphQLTaggedNode,
+    variables: TQuery['variables'],
+  ): TQuery['response'] {
+    return readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  }
 }
 
 module.exports = RelayRecordSourceProxy;

package/mutations/RelayRecordSourceSelectorProxy.js.flow

@@ -12,10 +12,7 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
-const {getStorageKey, ROOT_TYPE} = require('../store/RelayStoreUtils');
-
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
 import type {
   RecordProxy,
   RecordSourceProxy,
@@ -23,9 +20,15 @@ import type {
   SingularReaderSelector,
 } from '../store/RelayStoreTypes';
 import type {ReaderLinkedField} from '../util/ReaderNode';
-import type {DataID} from '../util/RelayRuntimeTypes';
+import type {DataID, OperationType} from '../util/RelayRuntimeTypes';
 import type RelayRecordSourceMutator from './RelayRecordSourceMutator';
 
+const {ROOT_TYPE, getStorageKey} = require('../store/RelayStoreUtils');
+const {
+  readUpdatableQuery_EXPERIMENTAL,
+} = require('./readUpdatableQuery_EXPERIMENTAL');
+const invariant = require('invariant');
+
 /**
  * @internal
  *
@@ -119,6 +122,13 @@ class RelayRecordSourceSelectorProxy implements RecordSourceSelectorProxy {
   invalidateStore(): void {
     this.__recordSource.invalidateStore();
   }
+
+  readUpdatableQuery_EXPERIMENTAL<TQuery: OperationType>(
+    query: GraphQLTaggedNode,
+    variables: TQuery['variables'],
+  ): TQuery['response'] {
+    return readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  }
 }
 
 module.exports = RelayRecordSourceSelectorProxy;

package/mutations/applyOptimisticMutation.js.flow

@@ -12,29 +12,28 @@
 
 'use strict';
 
-const RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
-
-const invariant = require('invariant');
-const isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
-
-const {getRequest} = require('../query/GraphQLTag');
-const {
-  createOperationDescriptor,
-} = require('../store/RelayModernOperationDescriptor');
-
 import type {GraphQLTaggedNode} from '../query/GraphQLTag';
 import type {
   IEnvironment,
+  MutationParameters,
   SelectorStoreUpdater,
 } from '../store/RelayStoreTypes';
 import type {Disposable, Variables} from '../util/RelayRuntimeTypes';
 import type {DeclarativeMutationConfig} from './RelayDeclarativeMutationConfig';
 
-export type OptimisticMutationConfig = {|
+const {getRequest} = require('../query/GraphQLTag');
+const isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
+const {
+  createOperationDescriptor,
+} = require('../store/RelayModernOperationDescriptor');
+const RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
+const invariant = require('invariant');
+
+export type OptimisticMutationConfig<TMutation: MutationParameters> = {|
   configs?: ?Array<DeclarativeMutationConfig>,
   mutation: GraphQLTaggedNode,
   variables: Variables,
-  optimisticUpdater?: ?SelectorStoreUpdater,
+  optimisticUpdater?: ?SelectorStoreUpdater<TMutation['response']>,
   optimisticResponse?: Object,
 |};
 
@@ -42,9 +41,9 @@ export type OptimisticMutationConfig = {|
  * Higher-level helper function to execute a mutation against a specific
  * environment.
  */
-function applyOptimisticMutation(
+function applyOptimisticMutation<TMutation: MutationParameters>(
   environment: IEnvironment,
-  config: OptimisticMutationConfig,
+  config: OptimisticMutationConfig<TMutation>,
 ): Disposable {
   invariant(
     isRelayModernEnvironment(environment),

package/mutations/commitLocalUpdate.js.flow

@@ -12,7 +12,7 @@
 
 'use strict';
 
-import type {StoreUpdater, IEnvironment} from '../store/RelayStoreTypes';
+import type {IEnvironment, StoreUpdater} from '../store/RelayStoreTypes';
 
 function commitLocalUpdate(
   environment: IEnvironment,