relay-runtime 11.0.2 → 12.0.0

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

@@ -13,6 +13,7 @@
 
 import type {PayloadData, GraphQLResponse} from '../network/RelayNetworkTypes';
 import type RelayObservable from '../network/RelayObservable';
+import type RelayPublishQueue from '../store/RelayPublishQueue';
 import type {
   OperationAvailability,
   OperationDescriptor,
@@ -24,10 +25,17 @@ import type {
   StoreUpdater,
   IEnvironment,
   ExecuteMutationConfig,
+  RecordSourceProxy,
 } from '../store/RelayStoreTypes';
 import type {Disposable} from '../util/RelayRuntimeTypes';
 import type {ActorIdentifier} from './ActorIdentifier';
 
+export type MultiActorStoreUpdater = (
+  actorIdentifier: ActorIdentifier,
+  environment: IActorEnvironment,
+  store: RecordSourceProxy,
+) => void;
+
 /**
  * Interface of actor specific sub-environment
  */
@@ -42,6 +50,17 @@ export interface IActorEnvironment extends IEnvironment {
    * Identifier of the actor for the current active environment
    */
   +actorIdentifier: ActorIdentifier;
+
+  /**
+   * TODO: this needs to move the the MultiActorEnvironment with different API.
+   */
+  getPublishQueue(): RelayPublishQueue;
+
+  /**
+   * Optional. A human-readable identifier of the environment.
+   * This value should be visible in the dev tools.
+   */
+  +configName: ?string;
 }
 
 /**
@@ -64,7 +83,7 @@ export interface IMultiActorEnvironment {
    * selector.
    */
   check(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     operation: OperationDescriptor,
   ): OperationAvailability;
 
@@ -74,7 +93,7 @@ export interface IMultiActorEnvironment {
    * the snapshot's selector to change.
    */
   subscribe(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     snapshot: Snapshot,
     callback: (snapshot: Snapshot) => void,
   ): Disposable;
@@ -85,7 +104,7 @@ export interface IMultiActorEnvironment {
    * until the returned reference is disposed.
    */
   retain(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     operation: OperationDescriptor,
   ): Disposable;
 
@@ -94,16 +113,33 @@ export interface IMultiActorEnvironment {
    * by calling `dispose()` on the returned value.
    */
   applyUpdate(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     optimisticUpdate: OptimisticUpdateFunction,
   ): Disposable;
 
+  /**
+   * Revert updates for the `update` function.
+   */
+  revertUpdate(
+    actorEnvironment: IActorEnvironment,
+    update: OptimisticUpdateFunction,
+  ): void;
+
+  /**
+   * Revert updates for the `update` function, and apply the `replacement` update.
+   */
+  replaceUpdate(
+    actorEnvironment: IActorEnvironment,
+    update: OptimisticUpdateFunction,
+    replacement: OptimisticUpdateFunction,
+  ): void;
+
   /**
    * Apply an optimistic mutation response and/or updater. The mutation can be
    * reverted by calling `dispose()` on the returned value.
    */
   applyMutation(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     optimisticConfig: OptimisticResponseConfig,
   ): Disposable;
 
@@ -112,13 +148,21 @@ export interface IMultiActorEnvironment {
    * should therefore not be used for optimistic updates. This is mainly
    * intended for updating fields from client schema extensions.
    */
-  commitUpdate(actorIdentifier: ActorIdentifier, updater: StoreUpdater): void;
+  commitUpdate(
+    actorEnvironment: IActorEnvironment,
+    updater: StoreUpdater,
+  ): void;
+
+  /**
+   * Commit store updates for each actor-specific environment known to MultiActorEnvironment
+   */
+  commitMultiActorUpdate(updater: MultiActorStoreUpdater): void;
 
   /**
    * Commit a payload to the environment using the given operation selector.
    */
   commitPayload(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     operationDescriptor: OperationDescriptor,
     payload: PayloadData,
   ): void;
@@ -127,7 +171,7 @@ export interface IMultiActorEnvironment {
    * Read the results of a selector from in-memory records in the store.
    */
   lookup(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     selector: SingularReaderSelector,
   ): Snapshot;
 
@@ -143,7 +187,7 @@ export interface IMultiActorEnvironment {
    * the result is subscribed to: environment.execute({...}).subscribe({...}).
    */
   execute(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     config: {
       operation: OperationDescriptor,
       updater?: ?SelectorStoreUpdater,
@@ -161,7 +205,7 @@ export interface IMultiActorEnvironment {
    * environment.executeMutation({...}).subscribe({...}).
    */
   executeMutation(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     config: ExecuteMutationConfig,
   ): RelayObservable<GraphQLResponse>;
 
@@ -175,7 +219,7 @@ export interface IMultiActorEnvironment {
    * environment.executeWithSource({...}).subscribe({...}).
    */
   executeWithSource(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     {
       operation: OperationDescriptor,
       source: RelayObservable<GraphQLResponse>,
@@ -190,7 +234,12 @@ export interface IMultiActorEnvironment {
    * active GraphQL subscription
    */
   isRequestActive(
-    actorIdentifier: ActorIdentifier,
+    actorEnvironment: IActorEnvironment,
     requestIdentifier: string,
   ): boolean;
+
+  /**
+   * Returns `true` if execute in the server environment
+   */
+  isServer(): boolean;
 }

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

@@ -13,6 +13,8 @@
 
 const MultiActorEnvironment = require('./MultiActorEnvironment');
 
+const {getActorIdentifier} = require('./ActorIdentifier');
+
 export type {ActorIdentifier} from './ActorIdentifier';
 export type {
   IActorEnvironment,
@@ -21,4 +23,5 @@ export type {
 
 module.exports = {
   MultiActorEnvironment,
+  getActorIdentifier,
 };

package/mutations/RelayRecordSourceSelectorProxy.js.flow

@@ -78,10 +78,15 @@ class RelayRecordSourceSelectorProxy implements RecordSourceSelectorProxy {
     fieldName: string,
     plural: boolean,
   ): ReaderLinkedField {
-    const field = selector.node.selections.find(
+    let field = selector.node.selections.find(
       selection =>
-        selection.kind === 'LinkedField' && selection.name === fieldName,
+        (selection.kind === 'LinkedField' && selection.name === fieldName) ||
+        (selection.kind === 'RequiredField' &&
+          selection.field.name === fieldName),
     );
+    if (field && field.kind === 'RequiredField') {
+      field = field.field;
+    }
     invariant(
       field && field.kind === 'LinkedField',
       'RelayRecordSourceSelectorProxy#getRootField(): Cannot find root ' +

package/mutations/commitMutation.js.flow

@@ -113,6 +113,8 @@ function commitMutation<T: MutationParameters>(
   } = config;
   const operation = createOperationDescriptor(
     mutation,
+    /* $FlowFixMe[class-object-subtyping] added when improving typing for this
+     * parameters */
     variables,
     cacheConfig,
     generateUniqueClientID(),

package/mutations/validateMutation.js.flow

@@ -30,9 +30,11 @@ type ValidationContext = {|
 
 const warning = require('warning');
 
+// $FlowFixMe[method-unbinding] added when improving typing for this parameters
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 const {
+  ACTOR_CHANGE,
   CONDITION,
   CLIENT_COMPONENT,
   CLIENT_EXTENSION,
@@ -128,6 +130,12 @@ if (__DEV__) {
       case LINKED_FIELD:
       case FLIGHT_FIELD:
         return validateField(optimisticResponse, selection, context);
+      case ACTOR_CHANGE:
+        return validateField(
+          optimisticResponse,
+          selection.linkedField,
+          context,
+        );
       case INLINE_FRAGMENT:
         const type = selection.type;
         const isConcreteType = selection.abstractKey == null;

package/network/RelayObservable.js.flow

@@ -355,11 +355,13 @@ class RelayObservable<+T> implements Subscribable<T> {
         }
       }
 
+      // $FlowFixMe[incompatible-call]
       this.subscribe({
         start,
         next(value) {
           try {
             if (!sink.closed) {
+              // $FlowFixMe[incompatible-call]
               RelayObservable.from(fn(value)).subscribe({
                 start,
                 next: sink.next,

package/network/RelayQueryResponseCache.js.flow

@@ -16,11 +16,14 @@ const invariant = require('invariant');
 const stableCopy = require('../util/stableCopy');
 
 import type {Variables} from '../util/RelayRuntimeTypes';
-import type {GraphQLSingularResponse} from './RelayNetworkTypes';
+import type {
+  GraphQLResponse,
+  GraphQLSingularResponse,
+} from './RelayNetworkTypes';
 
 type Response = {
   fetchTime: number,
-  payload: GraphQLSingularResponse,
+  payload: GraphQLResponse,
   ...
 };
 
@@ -55,7 +58,7 @@ class RelayQueryResponseCache {
     this._responses.clear();
   }
 
-  get(queryID: string, variables: Variables): ?GraphQLSingularResponse {
+  get(queryID: string, variables: Variables): ?GraphQLResponse {
     const cacheKey = getCacheKey(queryID, variables);
     this._responses.forEach((response, key) => {
       if (!isCurrent(response.fetchTime, this._ttl)) {
@@ -63,23 +66,33 @@ class RelayQueryResponseCache {
       }
     });
     const response = this._responses.get(cacheKey);
-    return response != null
-      ? // $FlowFixMe[speculation-ambiguous]
-        ({
-          ...response.payload,
-          extensions: {
-            ...response.payload.extensions,
-            cacheTimestamp: response.fetchTime,
-          },
-        }: GraphQLSingularResponse)
-      : null;
+    if (response == null) {
+      return null;
+    }
+    if (Array.isArray(response.payload)) {
+      return response.payload.map(
+        payload =>
+          // $FlowFixMe[incompatible-cast]
+          ({
+            ...payload,
+            extensions: {
+              ...payload.extensions,
+              cacheTimestamp: response.fetchTime,
+            },
+          }: GraphQLSingularResponse),
+      );
+    }
+    // $FlowFixMe[incompatible-cast]
+    return ({
+      ...response.payload,
+      extensions: {
+        ...response.payload.extensions,
+        cacheTimestamp: response.fetchTime,
+      },
+    }: GraphQLSingularResponse);
   }
 
-  set(
-    queryID: string,
-    variables: Variables,
-    payload: GraphQLSingularResponse,
-  ): void {
+  set(queryID: string, variables: Variables, payload: GraphQLResponse): void {
     const fetchTime = Date.now();
     const cacheKey = getCacheKey(queryID, variables);
     this._responses.delete(cacheKey); // deletion resets key ordering

package/network/wrapNetworkWithLogObserver.js.flow

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const generateID = require('../util/generateID');
+
+import type ActorSpecificEnvironment from '../multi-actor-environment/ActorSpecificEnvironment';
+import type RelayModernEnvironment from '../store/RelayModernEnvironment';
+import type {RequestParameters} from '../util/RelayConcreteNode';
+import type {CacheConfig, Variables} from '../util/RelayRuntimeTypes';
+import type {
+  INetwork,
+  GraphQLResponse,
+  UploadableMap,
+} from './RelayNetworkTypes';
+import type RelayObservable from './RelayObservable';
+
+/**
+ * Wraps the network with logging to ensure that network requests are
+ * always logged. Relying on each network callsite to be wrapped is
+ * untenable and will eventually lead to holes in the logging.
+ * NOTE: This function takes an environment instance, because Relay
+ * devtools will mutate the `env.__log` method, and the devtools rely
+ * on it to receive network events.
+ */
+function wrapNetworkWithLogObserver(
+  env: RelayModernEnvironment | ActorSpecificEnvironment,
+  network: INetwork,
+): INetwork {
+  return {
+    execute(
+      params: RequestParameters,
+      variables: Variables,
+      cacheConfig: CacheConfig,
+      uploadables?: ?UploadableMap,
+    ): RelayObservable<GraphQLResponse> {
+      const networkRequestId = generateID();
+      const logObserver = {
+        start: subscription => {
+          env.__log({
+            name: 'network.start',
+            networkRequestId,
+            params,
+            variables,
+            cacheConfig,
+          });
+        },
+        next: response => {
+          env.__log({
+            name: 'network.next',
+            networkRequestId,
+            response,
+          });
+        },
+        error: error => {
+          env.__log({
+            name: 'network.error',
+            networkRequestId,
+            error,
+          });
+        },
+        complete: () => {
+          env.__log({
+            name: 'network.complete',
+            networkRequestId,
+          });
+        },
+        unsubscribe: () => {
+          env.__log({
+            name: 'network.unsubscribe',
+            networkRequestId,
+          });
+        },
+      };
+      const logRequestInfo = info => {
+        env.__log({
+          name: 'network.info',
+          networkRequestId,
+          info,
+        });
+      };
+      return network
+        .execute(params, variables, cacheConfig, uploadables, logRequestInfo)
+        .do(logObserver);
+    },
+  };
+}
+
+module.exports = wrapNetworkWithLogObserver;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "11.0.2",
+  "version": "12.0.0",
   "keywords": [
     "graphql",
     "relay"