relay-runtime 11.0.1 → 11.0.2

package/store/RelayReader.js.flow

@@ -28,6 +28,7 @@ const {
   LINKED_FIELD,
   MODULE_IMPORT,
   REQUIRED_FIELD,
+  RELAY_RESOLVER,
   SCALAR_FIELD,
   STREAM,
 } = require('../util/RelayConcreteNode');
@@ -44,15 +45,18 @@ const {
   getStorageKey,
   getModuleComponentKey,
 } = require('./RelayStoreUtils');
+const {withResolverContext} = require('./ResolverFragments');
 const {generateTypeID} = require('./TypeID');
 
 import type {
   ReaderFlightField,
+  ReaderFragment,
   ReaderFragmentSpread,
   ReaderInlineDataFragmentSpread,
   ReaderLinkedField,
   ReaderModuleImport,
   ReaderNode,
+  ReaderRelayResolver,
   ReaderRequiredField,
   ReaderScalarField,
   ReaderSelection,
@@ -327,6 +331,13 @@ class RelayReader {
           }
           break;
         }
+        case RELAY_RESOLVER: {
+          if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+            throw new Error('Relay Resolver fields are not yet supported.');
+          }
+          this._readResolverField(selection, record, data);
+          break;
+        }
         case FRAGMENT_SPREAD:
           this._createFragmentPointer(selection, record, data);
           break;
@@ -334,7 +345,11 @@ class RelayReader {
           this._readModuleImport(selection, record, data);
           break;
         case INLINE_DATA_FRAGMENT_SPREAD:
-          this._createInlineDataFragmentPointer(selection, record, data);
+          this._createInlineDataOrResolverFragmentPointer(
+            selection,
+            record,
+            data,
+          );
           break;
         case DEFER:
         case CLIENT_EXTENSION: {
@@ -404,6 +419,43 @@ class RelayReader {
     }
   }
 
+  _readResolverField(
+    selection: ReaderRelayResolver,
+    record: Record,
+    data: SelectorData,
+  ): ?mixed {
+    const {name, alias, resolverModule, fragment} = selection;
+    const key = {
+      __id: RelayModernRecord.getDataID(record),
+      __fragmentOwner: this._owner,
+      __fragments: {
+        [fragment.name]: {}, // Arguments to this fragment; not yet supported.
+      },
+    };
+    const resolverContext = {
+      getDataForResolverFragment: singularReaderSelector => {
+        const resolverFragmentData = {};
+        this._createInlineDataOrResolverFragmentPointer(
+          singularReaderSelector.node,
+          record,
+          resolverFragmentData,
+        );
+        const answer = resolverFragmentData[FRAGMENTS_KEY]?.[fragment.name];
+        invariant(
+          typeof answer === 'object' && answer !== null,
+          `Expected reader data to contain a __fragments property with a property for the fragment named ${fragment.name}, but it is missing.`,
+        );
+        return answer;
+      },
+    };
+    const resolverResult = withResolverContext(resolverContext, () =>
+      // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
+      resolverModule(key),
+    );
+    data[alias ?? name] = resolverResult;
+    return resolverResult;
+  }
+
   _readFlightField(
     field: ReaderFlightField,
     record: Record,
@@ -607,8 +659,8 @@ class RelayReader {
     }
   }
 
-  _createInlineDataFragmentPointer(
-    inlineDataFragmentSpread: ReaderInlineDataFragmentSpread,
+  _createInlineDataOrResolverFragmentPointer(
+    fragmentSpreadOrFragment: ReaderInlineDataFragmentSpread | ReaderFragment,
     record: Record,
     data: SelectorData,
   ): void {
@@ -626,12 +678,12 @@ class RelayReader {
     }
     const inlineData = {};
     this._traverseSelections(
-      inlineDataFragmentSpread.selections,
+      fragmentSpreadOrFragment.selections,
       record,
       inlineData,
     );
     // $FlowFixMe[cannot-write] - writing into read-only field
-    fragmentPointers[inlineDataFragmentSpread.name] = inlineData;
+    fragmentPointers[fragmentSpreadOrFragment.name] = inlineData;
   }
 }
 

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');
@@ -535,11 +534,40 @@ 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,
@@ -549,10 +577,10 @@ class RelayResponseNormalizer {
       fieldValue,
     );
     invariant(
-      typeof this._reactFlightPayloadDeserializer === 'function',
+      typeof reactFlightPayloadDeserializer === 'function',
       'RelayResponseNormalizer: Expected reactFlightPayloadDeserializer to ' +
         'be a function, got `%s`.',
-      this._reactFlightPayloadDeserializer,
+      reactFlightPayloadDeserializer,
     );
 
     if (reactFlightPayload.errors.length > 0) {
@@ -573,44 +601,60 @@ class RelayResponseNormalizer {
       }
     }
 
-    // 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.
+    const reactFlightID = generateClientID(
+      RelayModernRecord.getDataID(record),
+      getStorageKey(selection, this._variables),
+    );
+    let reactFlightClientResponseRecord = this._recordSource.get(reactFlightID);
+    if (reactFlightClientResponseRecord == null) {
+      reactFlightClientResponseRecord = RelayModernRecord.create(
+        reactFlightID,
+        REACT_FLIGHT_TYPE_NAME,
+      );
+      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 = this._reactFlightPayloadDeserializer(
+    const reactFlightClientResponse = reactFlightPayloadDeserializer(
       reactFlightPayload.tree,
     );
-    const reactFlightID = generateClientID(
-      RelayModernRecord.getDataID(record),
-      getStorageKey(selection, this._variables),
-    );
-    let reactFlightClientResponseRecord = this._recordSource.get(reactFlightID);
-    if (reactFlightClientResponseRecord == null) {
-      reactFlightClientResponseRecord = RelayModernRecord.create(
-        reactFlightID,
-        REACT_FLIGHT_TYPE_NAME,
-      );
-      this._recordSource.set(reactFlightID, reactFlightClientResponseRecord);
-    }
+
     RelayModernRecord.setValue(
       reactFlightClientResponseRecord,
       REACT_FLIGHT_TREE_STORAGE_KEY,
       reactFlightClientResponse,
     );
+
     const reachableExecutableDefinitions: Array<ReactFlightReachableExecutableDefinitions> = [];
     for (const query of reactFlightPayload.queries) {
       if (query.response.data != null) {
@@ -853,9 +897,6 @@ class RelayResponseNormalizer {
   }
 }
 
-const instrumentedNormalize: typeof normalize = RelayProfiler.instrument(
-  'RelayResponseNormalizer.normalize',
+module.exports = {
   normalize,
-);
-
-module.exports = {normalize: instrumentedNormalize};
+};

package/store/RelayStoreTypes.js.flow

@@ -658,13 +658,9 @@ export interface IEnvironment {
    * the result is subscribed to:
    * environment.executeMutation({...}).subscribe({...}).
    */
-  executeMutation({|
-    operation: OperationDescriptor,
-    optimisticUpdater?: ?SelectorStoreUpdater,
-    optimisticResponse?: ?Object,
-    updater?: ?SelectorStoreUpdater,
-    uploadables?: ?UploadableMap,
-  |}): RelayObservable<GraphQLResponse>;
+  executeMutation(
+    config: ExecuteMutationConfig,
+  ): RelayObservable<GraphQLResponse>;
 
   /**
    * Returns an Observable of GraphQLResponse resulting from executing the
@@ -936,7 +932,18 @@ export type RelayResponsePayload = {|
 |};
 
 /**
- * Public interface for Publish Queue
+ * Configuration on the executeMutation(...).
+ */
+export type ExecuteMutationConfig = {|
+  operation: OperationDescriptor,
+  optimisticUpdater?: ?SelectorStoreUpdater,
+  optimisticResponse?: ?Object,
+  updater?: ?SelectorStoreUpdater,
+  uploadables?: ?UploadableMap,
+|};
+
+/**
+ * Public interface for Publish Queue.
  */
 export interface PublishQueue {
   /**

package/store/ResolverFragments.js.flow

@@ -0,0 +1,125 @@
+/**
+ * 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 strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const invariant = require('invariant');
+
+const {getFragment} = require('../query/GraphQLTag');
+const {getSelector} = require('./RelayModernSelector');
+
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {
+  FragmentReference,
+  SingularReaderSelector,
+} from './RelayStoreTypes';
+
+// When we call the user-supplied resolver function, it will in turn call
+// `readFragment`, but that's a global function -- it needs information
+// about what resolver is being executed, which is supplied by putting the
+// info on this stack before we call the resolver function.
+type ResolverContext = {|
+  getDataForResolverFragment: SingularReaderSelector => mixed,
+|};
+const contextStack: Array<ResolverContext> = [];
+
+function withResolverContext<T>(context: ResolverContext, cb: () => T): T {
+  contextStack.push(context);
+  try {
+    return cb();
+  } finally {
+    contextStack.pop();
+  }
+}
+
+// NOTE: these declarations are copied from 'useFragment'; it would be good
+// to figure out how to share the same type signature between the two functions.
+// The declarations ensure that the type of the returned data is:
+//   - non-nullable if the provided ref type is non-nullable
+//   - nullable if the provided ref type is nullable
+//   - array of non-nullable if the privoided ref type is an array of
+//     non-nullable refs
+//   - array of nullable if the privoided ref type is an array of nullable refs
+
+declare function readFragment<
+  TKey: {+$data?: mixed, +$fragmentRefs: FragmentReference, ...},
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): $Call<<TFragmentData>({+$data?: TFragmentData, ...}) => TFragmentData, TKey>;
+
+declare function readFragment<
+  TKey: ?{+$data?: mixed, +$fragmentRefs: FragmentReference, ...},
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): $Call<
+  <TFragmentData>(?{+$data?: TFragmentData, ...}) => ?TFragmentData,
+  TKey,
+>;
+
+declare function readFragment<
+  TKey: $ReadOnlyArray<{
+    +$data?: mixed,
+    +$fragmentRefs: FragmentReference,
+    ...
+  }>,
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): $Call<
+  <TFragmentData>(
+    $ReadOnlyArray<{+$data?: TFragmentData, ...}>,
+  ) => TFragmentData,
+  TKey,
+>;
+
+declare function readFragment<
+  TKey: ?$ReadOnlyArray<{
+    +$data?: mixed,
+    +$fragmentRefs: FragmentReference,
+    ...
+  }>,
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: TKey,
+): $Call<
+  <TFragmentData>(
+    ?$ReadOnlyArray<{+$data?: TFragmentData, ...}>,
+  ) => ?TFragmentData,
+  TKey,
+>;
+
+function readFragment(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentRef: mixed,
+): mixed {
+  if (!contextStack.length) {
+    throw new Error(
+      'readFragment should be called only from within a Relay Resolver function.',
+    );
+  }
+  const context = contextStack[contextStack.length - 1];
+  const fragmentNode = getFragment(fragmentInput);
+  const fragmentSelector = getSelector(fragmentNode, fragmentRef);
+  invariant(
+    fragmentSelector != null,
+    `Expected a selector for the fragment of the resolver ${fragmentNode.name}, but got null.`,
+  );
+  invariant(
+    fragmentSelector.kind === 'SingularReaderSelector',
+    `Expected a singular reader selector for the fragment of the resolver ${fragmentNode.name}, but it was plural.`,
+  );
+  return context.getDataForResolverFragment(fragmentSelector);
+}
+
+module.exports = {readFragment, withResolverContext};

package/subscription/requestSubscription.js.flow

@@ -22,6 +22,7 @@ const {generateUniqueClientID} = require('../store/ClientID');
 const {
   createOperationDescriptor,
 } = require('../store/RelayModernOperationDescriptor');
+const {createReaderSelector} = require('../store/RelayModernSelector');
 
 import type {DeclarativeMutationConfig} from '../mutations/RelayDeclarativeMutationConfig';
 import type {GraphQLTaggedNode} from '../query/GraphQLTag';
@@ -91,17 +92,24 @@ function requestSubscription<TSubscriptionPayload>(
       updater,
     })
     .map(responses => {
+      let selector = operation.fragment;
       if (RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {
+        let nextID;
         if (Array.isArray(responses)) {
-          // $FlowFixMe[incompatible-cast]
-          return (responses.map(
-            response => response.data,
-          ): TSubscriptionPayload);
+          nextID = responses[0]?.extensions?.__relay_subscription_root_id;
+        } else {
+          nextID = responses.extensions?.__relay_subscription_root_id;
+        }
+        if (typeof nextID === 'string') {
+          selector = createReaderSelector(
+            selector.node,
+            nextID,
+            selector.variables,
+            selector.owner,
+          );
         }
-        // $FlowFixMe[incompatible-cast]
-        return (responses.data: TSubscriptionPayload);
       }
-      const data = environment.lookup(operation.fragment).data;
+      const data = environment.lookup(selector).data;
       // $FlowFixMe[incompatible-cast]
       return (data: TSubscriptionPayload);
     })

package/util/ReaderNode.js.flow

@@ -206,6 +206,18 @@ export type ReaderRequiredField = {|
   +path: string,
 |};
 
+export type ReaderRelayResolver = {|
+  +kind: 'RelayResolver',
+  +alias: ?string,
+  +name: string,
+  +fragment: ReaderFragmentSpread,
+  +resolverModule: (rootKey: {
+    +$data?: any, // flowlint-line unclear-type:off
+    +$fragmentRefs: any, // flowlint-line unclear-type:off
+    ...
+  }) => mixed,
+|};
+
 export type ReaderSelection =
   | ReaderCondition
   | ReaderClientExtension
@@ -217,7 +229,8 @@ export type ReaderSelection =
   | ReaderInlineFragment
   | ReaderModuleImport
   | ReaderStream
-  | ReaderRequiredField;
+  | ReaderRequiredField
+  | ReaderRelayResolver;
 
 export type ReaderVariableArgument = {|
   +kind: 'Variable',

package/util/RelayConcreteNode.js.flow

@@ -84,6 +84,7 @@ const RelayConcreteNode = {
   LIST_VALUE: 'ListValue',
   LOCAL_ARGUMENT: 'LocalArgument',
   MODULE_IMPORT: 'ModuleImport',
+  RELAY_RESOLVER: 'RelayResolver',
   REQUIRED_FIELD: 'RequiredField',
   OBJECT_VALUE: 'ObjectValue',
   OPERATION: 'Operation',

package/util/RelayFeatureFlags.js.flow

@@ -19,6 +19,7 @@ type FeatureFlags = {|
   ENABLE_PRECISE_TYPE_REFINEMENT: boolean,
   ENABLE_REACT_FLIGHT_COMPONENT_FIELD: boolean,
   ENABLE_REQUIRED_DIRECTIVES: boolean | string,
+  ENABLE_RELAY_RESOLVERS: boolean,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: boolean,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: boolean,
   ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: boolean,
@@ -26,6 +27,7 @@ type FeatureFlags = {|
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: boolean,
   ENABLE_NOTIFY_SUBSCRIPTION: boolean,
   ENABLE_UNIQUE_SUBSCRIPTION_ROOT: boolean,
+  ENABLE_BATCHED_STORE_UPDATES: boolean,
 |};
 
 const RelayFeatureFlags: FeatureFlags = {
@@ -35,6 +37,7 @@ const RelayFeatureFlags: FeatureFlags = {
   ENABLE_PRECISE_TYPE_REFINEMENT: false,
   ENABLE_REACT_FLIGHT_COMPONENT_FIELD: false,
   ENABLE_REQUIRED_DIRECTIVES: false,
+  ENABLE_RELAY_RESOLVERS: false,
   ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,
   ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,
   ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: false,
@@ -42,6 +45,7 @@ const RelayFeatureFlags: FeatureFlags = {
   ENABLE_DO_NOT_WRAP_LIVE_QUERY: false,
   ENABLE_NOTIFY_SUBSCRIPTION: false,
   ENABLE_UNIQUE_SUBSCRIPTION_ROOT: false,
+  ENABLE_BATCHED_STORE_UPDATES: false,
 };
 
 module.exports = RelayFeatureFlags;