relay-runtime 10.1.3 → 11.0.2

package/store/RelayResponseNormalizer.js.flow

@@ -14,7 +14,6 @@
 
 const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const RelayModernRecord = require('./RelayModernRecord');
-const RelayProfiler = require('../util/RelayProfiler');
 
 const areEqual = require('areEqual');
 const invariant = require('invariant');
@@ -22,9 +21,11 @@ const warning = require('warning');
 
 const {
   CONDITION,
+  CLIENT_COMPONENT,
   CLIENT_EXTENSION,
   DEFER,
   FLIGHT_FIELD,
+  FRAGMENT_SPREAD,
   INLINE_FRAGMENT,
   LINKED_FIELD,
   LINKED_HANDLE,
@@ -38,7 +39,7 @@ const {generateClientID, isClientID} = require('./ClientID');
 const {createNormalizationSelector} = require('./RelayModernSelector');
 const {
   refineToReactFlightPayloadData,
-  REACT_FLIGHT_QUERIES_STORAGE_KEY,
+  REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
   REACT_FLIGHT_TREE_STORAGE_KEY,
   REACT_FLIGHT_TYPE_NAME,
 } = require('./RelayStoreReactFlightUtils');
@@ -71,14 +72,15 @@ import type {
   ModuleImportPayload,
   MutableRecordSource,
   NormalizationSelector,
-  ReactFlightReachableQuery,
+  ReactFlightReachableExecutableDefinitions,
   ReactFlightPayloadDeserializer,
+  ReactFlightServerErrorHandler,
   Record,
   RelayResponsePayload,
 } from './RelayStoreTypes';
 
 export type GetDataID = (
-  fieldValue: {[string]: mixed, ...},
+  fieldValue: interface {[string]: mixed},
   typeName: string,
 ) => mixed;
 
@@ -87,6 +89,8 @@ export type NormalizationOptions = {|
   +treatMissingFieldsAsNull: boolean,
   +path?: $ReadOnlyArray<string>,
   +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
+  +reactFlightServerErrorHandler?: ?ReactFlightServerErrorHandler,
+  +shouldProcessClientComponents?: ?boolean,
 |};
 
 /**
@@ -125,6 +129,8 @@ class RelayResponseNormalizer {
   _recordSource: MutableRecordSource;
   _variables: Variables;
   _reactFlightPayloadDeserializer: ?ReactFlightPayloadDeserializer;
+  _reactFlightServerErrorHandler: ?ReactFlightServerErrorHandler;
+  _shouldProcessClientComponents: ?boolean;
 
   constructor(
     recordSource: MutableRecordSource,
@@ -143,6 +149,8 @@ class RelayResponseNormalizer {
     this._variables = variables;
     this._reactFlightPayloadDeserializer =
       options.reactFlightPayloadDeserializer;
+    this._reactFlightServerErrorHandler = options.reactFlightServerErrorHandler;
+    this._shouldProcessClientComponents = options.shouldProcessClientComponents;
   }
 
   normalizeResponse(
@@ -173,6 +181,7 @@ class RelayResponseNormalizer {
       'RelayResponseNormalizer(): Undefined variable `%s`.',
       name,
     );
+    // $FlowFixMe[cannot-write]
     return this._variables[name];
   }
 
@@ -204,6 +213,10 @@ class RelayResponseNormalizer {
             this._traverseSelections(selection, record, data);
           }
           break;
+        case FRAGMENT_SPREAD: {
+          this._traverseSelections(selection.fragment, record, data);
+          break;
+        }
         case INLINE_FRAGMENT: {
           const {abstractKey} = selection;
           if (abstractKey == null) {
@@ -293,6 +306,12 @@ class RelayResponseNormalizer {
           this._traverseSelections(selection, record, data);
           this._isClientExtension = isClientExtension;
           break;
+        case CLIENT_COMPONENT:
+          if (this._shouldProcessClientComponents === false) {
+            break;
+          }
+          this._traverseSelections(selection.fragment, record, data);
+          break;
         case FLIGHT_FIELD:
           if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {
             this._normalizeFlightField(node, selection, record, data);
@@ -515,31 +534,73 @@ class RelayResponseNormalizer {
     const fieldValue = data[responseKey];
 
     if (fieldValue == null) {
+      if (fieldValue === undefined) {
+        // Flight field may be missing in the response if:
+        // - It is inside an abstract type refinement where the concrete type does
+        //   not conform to the interface/union.
+        // However an otherwise-required field may also be missing if the server
+        // is configured to skip fields with `null` values, in which case the
+        // client is assumed to be correctly configured with
+        // treatMissingFieldsAsNull=true.
+        if (this._isUnmatchedAbstractType) {
+          // Field not expected to exist regardless of whether the server is pruning null
+          // fields or not.
+          return;
+        } else if (!this._treatMissingFieldsAsNull) {
+          // Not optional and the server is not pruning null fields: field is expected
+          // to be present
+          if (__DEV__) {
+            warning(
+              false,
+              'RelayResponseNormalizer: Payload did not contain a value ' +
+                'for field `%s: %s`. Check that you are parsing with the same ' +
+                'query that was used to fetch the payload.',
+              responseKey,
+              storageKey,
+            );
+          }
+          return;
+        }
+      }
       RelayModernRecord.setValue(record, storageKey, null);
       return;
     }
 
     const reactFlightPayload = refineToReactFlightPayloadData(fieldValue);
+    const reactFlightPayloadDeserializer = this._reactFlightPayloadDeserializer;
 
     invariant(
       reactFlightPayload != null,
-      'RelayResponseNormalizer(): Expected React Flight payload data ' +
-        'to be an object with `tree` and `queries` properties, got `%s`.',
+      'RelayResponseNormalizer: Expected React Flight payload data to be an ' +
+        'object with `status`, tree`, `queries` and `errors` properties, got ' +
+        '`%s`.',
       fieldValue,
     );
     invariant(
-      typeof this._reactFlightPayloadDeserializer === 'function',
+      typeof reactFlightPayloadDeserializer === 'function',
       'RelayResponseNormalizer: Expected reactFlightPayloadDeserializer to ' +
         'be a function, got `%s`.',
-      this._reactFlightPayloadDeserializer,
+      reactFlightPayloadDeserializer,
     );
 
-    // We store the deserialized reactFlightClientResponse in a separate
-    // record and link it to the parent record. This is so we can GC the Flight
-    // tree later even if the parent record is still reachable.
-    const reactFlightClientResponse = this._reactFlightPayloadDeserializer(
-      reactFlightPayload.tree,
-    );
+    if (reactFlightPayload.errors.length > 0) {
+      if (typeof this._reactFlightServerErrorHandler === 'function') {
+        this._reactFlightServerErrorHandler(
+          reactFlightPayload.status,
+          reactFlightPayload.errors,
+        );
+      } else {
+        warning(
+          false,
+          'RelayResponseNormalizer: Received server errors for field `%s`.\n\n' +
+            '%s\n%s',
+          responseKey,
+          reactFlightPayload.errors[0].message,
+          reactFlightPayload.errors[0].stack,
+        );
+      }
+    }
+
     const reactFlightID = generateClientID(
       RelayModernRecord.getDataID(record),
       getStorageKey(selection, this._variables),
@@ -552,12 +613,49 @@ class RelayResponseNormalizer {
       );
       this._recordSource.set(reactFlightID, reactFlightClientResponseRecord);
     }
+
+    if (reactFlightPayload.tree == null) {
+      // This typically indicates that a fatal server error prevented rows from
+      // being written. When this occurs, we should not continue normalization of
+      // the Flight field because the row response is malformed.
+      //
+      // Receiving empty rows is OK because it can indicate the start of a stream.
+      warning(
+        false,
+        'RelayResponseNormalizer: Expected `tree` not to be null. This ' +
+          'typically indicates that a fatal server error prevented any Server ' +
+          'Component rows from being written.',
+      );
+      // We create the flight record with a null value for the tree
+      // and empty reachable definitions
+      RelayModernRecord.setValue(
+        reactFlightClientResponseRecord,
+        REACT_FLIGHT_TREE_STORAGE_KEY,
+        null,
+      );
+      RelayModernRecord.setValue(
+        reactFlightClientResponseRecord,
+        REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
+        [],
+      );
+      RelayModernRecord.setLinkedRecordID(record, storageKey, reactFlightID);
+      return;
+    }
+
+    // We store the deserialized reactFlightClientResponse in a separate
+    // record and link it to the parent record. This is so we can GC the Flight
+    // tree later even if the parent record is still reachable.
+    const reactFlightClientResponse = reactFlightPayloadDeserializer(
+      reactFlightPayload.tree,
+    );
+
     RelayModernRecord.setValue(
       reactFlightClientResponseRecord,
       REACT_FLIGHT_TREE_STORAGE_KEY,
       reactFlightClientResponse,
     );
-    const reachableQueries: Array<ReactFlightReachableQuery> = [];
+
+    const reachableExecutableDefinitions: Array<ReactFlightReachableExecutableDefinitions> = [];
     for (const query of reactFlightPayload.queries) {
       if (query.response.data != null) {
         this._moduleImportPayloads.push({
@@ -569,15 +667,31 @@ class RelayResponseNormalizer {
           variables: query.variables,
         });
       }
-      reachableQueries.push({
+      reachableExecutableDefinitions.push({
         module: query.module,
         variables: query.variables,
       });
     }
+    for (const fragment of reactFlightPayload.fragments) {
+      if (fragment.response.data != null) {
+        this._moduleImportPayloads.push({
+          data: fragment.response.data,
+          dataID: fragment.__id,
+          operationReference: fragment.module,
+          path: [],
+          typeName: fragment.__typename,
+          variables: fragment.variables,
+        });
+      }
+      reachableExecutableDefinitions.push({
+        module: fragment.module,
+        variables: fragment.variables,
+      });
+    }
     RelayModernRecord.setValue(
       reactFlightClientResponseRecord,
-      REACT_FLIGHT_QUERIES_STORAGE_KEY,
-      reachableQueries,
+      REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
+      reachableExecutableDefinitions,
     );
     RelayModernRecord.setLinkedRecordID(record, storageKey, reactFlightID);
   }
@@ -783,9 +897,6 @@ class RelayResponseNormalizer {
   }
 }
 
-const instrumentedNormalize: typeof normalize = RelayProfiler.instrument(
-  'RelayResponseNormalizer.normalize',
+module.exports = {
   normalize,
-);
-
-module.exports = {normalize: instrumentedNormalize};
+};

package/store/RelayStoreReactFlightUtils.js.flow

@@ -19,7 +19,9 @@ const {getType} = require('./RelayModernRecord');
 import type {ReactFlightPayloadData} from '../network/RelayNetworkTypes';
 import type {ReactFlightClientResponse, Record} from './RelayStoreTypes';
 
-const REACT_FLIGHT_QUERIES_STORAGE_KEY = 'queries';
+// Reachable (client) executable definitions encountered while server component
+// rendering
+const REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY = 'executableDefinitions';
 const REACT_FLIGHT_TREE_STORAGE_KEY = 'tree';
 const REACT_FLIGHT_TYPE_NAME = 'ReactFlightComponent';
 
@@ -29,8 +31,11 @@ function refineToReactFlightPayloadData(
   if (
     payload == null ||
     typeof payload !== 'object' ||
-    !Array.isArray(payload.tree) ||
-    !Array.isArray(payload.queries)
+    typeof payload.status !== 'string' ||
+    (!Array.isArray(payload.tree) && payload.tree !== null) ||
+    !Array.isArray(payload.queries) ||
+    !Array.isArray(payload.fragments) ||
+    !Array.isArray(payload.errors)
   ) {
     return null;
   }
@@ -56,7 +61,7 @@ function getReactFlightClientResponse(
 }
 
 module.exports = {
-  REACT_FLIGHT_QUERIES_STORAGE_KEY,
+  REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,
   REACT_FLIGHT_TREE_STORAGE_KEY,
   REACT_FLIGHT_TYPE_NAME,
   getReactFlightClientResponse,

package/store/RelayStoreSubscriptions.js.flow

@@ -12,20 +12,22 @@
 
 'use strict';
 
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const RelayReader = require('./RelayReader');
 
 const deepFreeze = require('../util/deepFreeze');
 const hasOverlappingIDs = require('./hasOverlappingIDs');
-const isEmptyObject = require('../util/isEmptyObject');
 const recycleNodesInto = require('../util/recycleNodesInto');
 
 import type {Disposable} from '../util/RelayRuntimeTypes';
 import type {
+  LogFunction,
+  OperationDescriptor,
+  DataIDSet,
   RecordSource,
   RequestDescriptor,
   Snapshot,
   StoreSubscriptions,
-  UpdatedRecords,
 } from './RelayStoreTypes';
 
 type Subscription = {|
@@ -37,9 +39,11 @@ type Subscription = {|
 
 class RelayStoreSubscriptions implements StoreSubscriptions {
   _subscriptions: Set<Subscription>;
+  __log: ?LogFunction;
 
-  constructor() {
+  constructor(log?: ?LogFunction) {
     this._subscriptions = new Set();
+    this.__log = log;
   }
 
   subscribe(
@@ -65,7 +69,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
       //   but its base has changed (we just applied a final payload): recompute
       //   a backup so that we can later restore to the state the subscription
       //   should be in.
-      // - stale=false: This subscription was restored to the same value than
+      // - stale=false: This subscription was restored to the same value as
       //   `snapshot`. That means this subscription does *not* have changes relative
       //   to its base, so the current `snapshot` is valid to use as a backup.
       if (!subscription.stale) {
@@ -103,16 +107,18 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
 
   updateSubscriptions(
     source: RecordSource,
-    updatedRecordIDs: UpdatedRecords,
+    updatedRecordIDs: DataIDSet,
     updatedOwners: Array<RequestDescriptor>,
+    sourceOperation?: OperationDescriptor,
   ) {
-    const hasUpdatedRecords = !isEmptyObject(updatedRecordIDs);
+    const hasUpdatedRecords = updatedRecordIDs.size !== 0;
     this._subscriptions.forEach(subscription => {
       const owner = this._updateSubscription(
         source,
         subscription,
         updatedRecordIDs,
         hasUpdatedRecords,
+        sourceOperation,
       );
       if (owner != null) {
         updatedOwners.push(owner);
@@ -131,8 +137,9 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
   _updateSubscription(
     source: RecordSource,
     subscription: Subscription,
-    updatedRecordIDs: UpdatedRecords,
+    updatedRecordIDs: DataIDSet,
     hasUpdatedRecords: boolean,
+    sourceOperation?: OperationDescriptor,
   ): ?RequestDescriptor {
     const {backup, callback, snapshot, stale} = subscription;
     const hasOverlappingUpdates =
@@ -159,6 +166,14 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     subscription.snapshot = nextSnapshot;
     subscription.stale = false;
     if (nextSnapshot.data !== snapshot.data) {
+      if (this.__log && RelayFeatureFlags.ENABLE_NOTIFY_SUBSCRIPTION) {
+        this.__log({
+          name: 'store.notify.subscription',
+          sourceOperation,
+          snapshot,
+          nextSnapshot,
+        });
+      }
       callback(nextSnapshot);
       return snapshot.selector.owner;
     }

package/store/RelayStoreSubscriptionsUsingMapByID.js.flow

@@ -12,6 +12,7 @@
 
 'use strict';
 
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const RelayReader = require('./RelayReader');
 
 const deepFreeze = require('../util/deepFreeze');
@@ -19,12 +20,13 @@ const recycleNodesInto = require('../util/recycleNodesInto');
 
 import type {DataID, Disposable} from '../util/RelayRuntimeTypes';
 import type {
-  RecordMap,
+  LogFunction,
+  OperationDescriptor,
   RecordSource,
   RequestDescriptor,
   Snapshot,
   StoreSubscriptions,
-  UpdatedRecords,
+  DataIDSet,
 } from './RelayStoreTypes';
 
 type Subscription = {|
@@ -40,12 +42,14 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
   _snapshotRevision: number;
   _subscriptionsByDataId: Map<DataID, Set<Subscription>>;
   _staleSubscriptions: Set<Subscription>;
+  __log: ?LogFunction;
 
-  constructor() {
+  constructor(log?: ?LogFunction) {
     this._notifiedRevision = 0;
     this._snapshotRevision = 0;
     this._subscriptionsByDataId = new Map();
     this._staleSubscriptions = new Set();
+    this.__log = log;
   }
 
   subscribe(
@@ -60,7 +64,7 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
       snapshot,
     };
     const dispose = () => {
-      for (const dataId in snapshot.seenRecords) {
+      for (const dataId of snapshot.seenRecords) {
         const subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);
         if (subscriptionsForDataId != null) {
           subscriptionsForDataId.delete(subscription);
@@ -71,7 +75,7 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
       }
     };
 
-    for (const dataId in snapshot.seenRecords) {
+    for (const dataId of snapshot.seenRecords) {
       const subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);
       if (subscriptionsForDataId != null) {
         subscriptionsForDataId.add(subscription);
@@ -150,11 +154,12 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
 
   updateSubscriptions(
     source: RecordSource,
-    updatedRecordIDs: UpdatedRecords,
+    updatedRecordIDs: DataIDSet,
     updatedOwners: Array<RequestDescriptor>,
+    sourceOperation?: OperationDescriptor,
   ) {
     this._notifiedRevision++;
-    Object.keys(updatedRecordIDs).forEach(updatedRecordId => {
+    updatedRecordIDs.forEach(updatedRecordId => {
       const subcriptionsForDataId = this._subscriptionsByDataId.get(
         updatedRecordId,
       );
@@ -165,7 +170,12 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
         if (subscription.notifiedRevision === this._notifiedRevision) {
           return;
         }
-        const owner = this._updateSubscription(source, subscription, false);
+        const owner = this._updateSubscription(
+          source,
+          subscription,
+          false,
+          sourceOperation,
+        );
         if (owner != null) {
           updatedOwners.push(owner);
         }
@@ -175,7 +185,12 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
       if (subscription.notifiedRevision === this._notifiedRevision) {
         return;
       }
-      const owner = this._updateSubscription(source, subscription, true);
+      const owner = this._updateSubscription(
+        source,
+        subscription,
+        true,
+        sourceOperation,
+      );
       if (owner != null) {
         updatedOwners.push(owner);
       }
@@ -196,6 +211,7 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
     source: RecordSource,
     subscription: Subscription,
     stale: boolean,
+    sourceOperation?: OperationDescriptor,
   ): ?RequestDescriptor {
     const {backup, callback, snapshot} = subscription;
     let nextSnapshot: Snapshot =
@@ -220,6 +236,14 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
     this._updateSubscriptionsMap(subscription, prevSeenRecords);
 
     if (nextSnapshot.data !== snapshot.data) {
+      if (this.__log && RelayFeatureFlags.ENABLE_NOTIFY_SUBSCRIPTION) {
+        this.__log({
+          name: 'store.notify.subscription',
+          sourceOperation,
+          snapshot,
+          nextSnapshot,
+        });
+      }
       callback(nextSnapshot);
       return snapshot.selector.owner;
     }
@@ -233,9 +257,9 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
    */
   _updateSubscriptionsMap(
     subscription: Subscription,
-    prevSeenRecords: RecordMap,
+    prevSeenRecords: DataIDSet,
   ) {
-    for (const dataId in prevSeenRecords) {
+    for (const dataId of prevSeenRecords) {
       const subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);
       if (subscriptionsForDataId != null) {
         subscriptionsForDataId.delete(subscription);
@@ -245,7 +269,7 @@ class RelayStoreSubscriptionsUsingMapByID implements StoreSubscriptions {
       }
     }
 
-    for (const dataId in subscription.snapshot.seenRecords) {
+    for (const dataId of subscription.snapshot.seenRecords) {
       const subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);
       if (subscriptionsForDataId != null) {
         subscriptionsForDataId.add(subscription);