relay-runtime 10.1.3 → 11.0.2

package/store/RelayStoreTypes.js.flow

@@ -18,6 +18,7 @@ import type {
   PayloadData,
   PayloadError,
   ReactFlightServerTree,
+  ReactFlightServerError,
   UploadableMap,
 } from '../network/RelayNetworkTypes';
 import type RelayObservable from '../network/RelayObservable';
@@ -55,7 +56,7 @@ export type Record = {[key: string]: mixed, ...};
 /**
  * A collection of records keyed by id.
  */
-export type RecordMap = {[dataID: DataID]: ?Record, ...};
+export type RecordObjectMap = {[DataID]: ?Record};
 
 export type FragmentMap = {[key: string]: ReaderFragment, ...};
 
@@ -112,7 +113,7 @@ export type MissingRequiredFields =
 export type Snapshot = {|
   +data: ?SelectorData,
   +isMissingData: boolean,
-  +seenRecords: RecordMap,
+  +seenRecords: DataIDSet,
   +selector: SingularReaderSelector,
   +missingRequiredFields: ?MissingRequiredFields,
 |};
@@ -268,7 +269,7 @@ export interface Store {
    * internal record source. Subscribers are not immediately notified - this
    * occurs when `notify()` is called.
    */
-  publish(source: RecordSource, idsMarkedForInvalidation?: Set<DataID>): void;
+  publish(source: RecordSource, idsMarkedForInvalidation?: DataIDSet): void;
 
   /**
    * Ensure that all the records necessary to fulfill the given selector are
@@ -362,8 +363,9 @@ export interface StoreSubscriptions {
    */
   updateSubscriptions(
     source: RecordSource,
-    updatedRecordIDs: UpdatedRecords,
+    updatedRecordIDs: DataIDSet,
     updatedOwners: Array<RequestDescriptor>,
+    sourceOperation?: OperationDescriptor,
   ): void;
 }
 
@@ -451,9 +453,9 @@ export type LogEvent =
       +operation: OperationDescriptor,
       // value from ProfilerContext
       +profilerContext: mixed,
-      // FetchPolicy from relay-experimental
+      // FetchPolicy from Relay Hooks
       +fetchPolicy: string,
-      // RenderPolicy from relay-experimental
+      // RenderPolicy from Relay Hooks
       +renderPolicy: string,
       +queryAvailability: OperationAvailability,
       +shouldFetch: boolean,
@@ -474,6 +476,7 @@ export type LogEvent =
       +transactionID: number,
       +params: RequestParameters,
       +variables: Variables,
+      +cacheConfig: CacheConfig,
     |}
   | {|
       +name: 'network.next',
@@ -506,15 +509,23 @@ export type LogEvent =
     |}
   | {|
       +name: 'store.gc',
-      +references: Set<DataID>,
+      +references: DataIDSet,
     |}
   | {|
       +name: 'store.notify.start',
+      +sourceOperation: ?OperationDescriptor,
     |}
   | {|
       +name: 'store.notify.complete',
-      +updatedRecordIDs: UpdatedRecords,
-      +invalidatedRecordIDs: Set<DataID>,
+      +sourceOperation: ?OperationDescriptor,
+      +updatedRecordIDs: DataIDSet,
+      +invalidatedRecordIDs: DataIDSet,
+    |}
+  | {|
+      +name: 'store.notify.subscription',
+      +sourceOperation: ?OperationDescriptor,
+      +snapshot: Snapshot,
+      +nextSnapshot: Snapshot,
     |}
   | {|
       +name: 'entrypoint.root.consume',
@@ -647,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
@@ -704,9 +711,10 @@ export type ModuleImportPointer = {
 };
 
 /**
- * A map of records affected by an update operation.
+ * A set of DataIDs used to track which IDs a read() operation observed and which IDs
+ * a publish operation updated.
  */
-export type UpdatedRecords = {[dataID: DataID]: boolean, ...};
+export type DataIDSet = Set<DataID>;
 
 /**
  * A function that updates a store (via a proxy) given the results of a "handle"
@@ -924,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 {
   /**
@@ -978,15 +997,25 @@ export interface PublishQueue {
  */
 export type ReactFlightClientResponse = {readRoot: () => mixed, ...};
 
-export type ReactFlightReachableQuery = {|
+export type ReactFlightReachableExecutableDefinitions = {|
   +module: mixed,
   +variables: Variables,
 |};
 
 /**
- * A user-supplied function that takes a ReactFlightServerTree, and deserializes
- * it into a ReactFlightClientResponse object.
+ * A user-supplied function that takes a ReactFlightServerTree
+ * (after successful execution on the server), and deserializes it into a
+ * ReactFlightClientResponse object.
  */
 export type ReactFlightPayloadDeserializer = (
   tree: ReactFlightServerTree,
 ) => ReactFlightClientResponse;
+
+/**
+ * An optionally user-supplied function that handles errors returned by the
+ * server's JS runtime while executing a React Server Component.
+ */
+export type ReactFlightServerErrorHandler = (
+  status: string,
+  errors: Array<ReactFlightServerError>,
+) => void;

package/store/RelayStoreUtils.js.flow

@@ -26,7 +26,7 @@ import type {
 import type {ReaderArgument, ReaderField} from '../util/ReaderNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
-export type Arguments = {+[string]: mixed, ...};
+export type Arguments = interface {+[string]: mixed};
 
 const {VARIABLE, LITERAL, OBJECT_VALUE, LIST_VALUE} = RelayConcreteNode;
 
@@ -178,6 +178,7 @@ function getStableVariableValue(name: string, variables: Variables): mixed {
     'getVariableValue(): Undefined variable `%s`.',
     name,
   );
+  // $FlowFixMe[cannot-write]
   return stableCopy(variables[name]);
 }
 

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/store/createFragmentSpecResolver.js.flow

@@ -28,6 +28,7 @@ function createFragmentSpecResolver(
   containerName: string,
   fragments: FragmentMap,
   props: Props,
+  rootIsQueryRenderer: boolean,
   callback?: () => void,
 ): FragmentSpecResolver {
   if (__DEV__) {
@@ -49,6 +50,7 @@ function createFragmentSpecResolver(
     fragments,
     props,
     callback,
+    rootIsQueryRenderer,
   );
 }
 

package/store/defaultGetDataID.js.flow

@@ -15,12 +15,14 @@
 const {VIEWER_ID, VIEWER_TYPE} = require('./ViewerPattern');
 
 function defaultGetDataID(
-  fieldValue: {[string]: mixed, ...},
+  fieldValue: interface {[string]: mixed},
   typeName: string,
 ): mixed {
   if (typeName === VIEWER_TYPE) {
+    // $FlowFixMe[prop-missing]
     return fieldValue.id == null ? VIEWER_ID : fieldValue.id;
   }
+  // $FlowFixMe[prop-missing]
   return fieldValue.id;
 }
 

package/store/hasOverlappingIDs.js.flow

@@ -12,21 +12,23 @@
 
 'use strict';
 
-import type {RecordMap, UpdatedRecords} from './RelayStoreTypes';
+import type {DataIDSet} from './RelayStoreTypes';
 
-const hasOwnProperty = Object.prototype.hasOwnProperty;
+const ITERATOR_KEY = Symbol.iterator;
 
 function hasOverlappingIDs(
-  seenRecords: RecordMap,
-  updatedRecordIDs: UpdatedRecords,
+  seenRecords: DataIDSet,
+  updatedRecordIDs: DataIDSet,
 ): boolean {
-  for (const key in seenRecords) {
-    if (
-      hasOwnProperty.call(seenRecords, key) &&
-      hasOwnProperty.call(updatedRecordIDs, key)
-    ) {
+  // $FlowFixMe: Set is an iterable type, accessing its iterator is allowed.
+  const iterator = seenRecords[ITERATOR_KEY]();
+  let next = iterator.next();
+  while (!next.done) {
+    const key = next.value;
+    if (updatedRecordIDs.has(key)) {
       return true;
     }
+    next = iterator.next();
   }
   return false;
 }

package/subscription/requestSubscription.js.flow

@@ -13,13 +13,16 @@
 'use strict';
 
 const RelayDeclarativeMutationConfig = require('../mutations/RelayDeclarativeMutationConfig');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 const warning = require('warning');
 
 const {getRequest} = require('../query/GraphQLTag');
+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';
@@ -64,6 +67,9 @@ function requestSubscription<TSubscriptionPayload>(
     subscription,
     variables,
     cacheConfig,
+    RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT
+      ? generateUniqueClientID()
+      : undefined,
   );
 
   warning(
@@ -85,8 +91,25 @@ function requestSubscription<TSubscriptionPayload>(
       operation,
       updater,
     })
-    .map(() => {
-      const data = environment.lookup(operation.fragment).data;
+    .map(responses => {
+      let selector = operation.fragment;
+      if (RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {
+        let nextID;
+        if (Array.isArray(responses)) {
+          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,
+          );
+        }
+      }
+      const data = environment.lookup(selector).data;
       // $FlowFixMe[incompatible-cast]
       return (data: TSubscriptionPayload);
     })

package/util/NormalizationNode.js.flow

@@ -85,6 +85,12 @@ export type NormalizationInlineFragment = {|
   +abstractKey: ?string,
 |};
 
+export type NormalizationFragmentSpread = {|
+  +kind: 'FragmentSpread',
+  +fragment: NormalizationNode,
+  +args: ?$ReadOnlyArray<NormalizationArgument>,
+|};
+
 export type NormalizationLinkedField = {|
   +kind: 'LinkedField',
   +alias: ?string,
@@ -148,6 +154,11 @@ export type NormalizationFlightField = {|
   +storageKey: ?string,
 |};
 
+export type NormalizationClientComponent = {|
+  +kind: 'ClientComponent',
+  +fragment: NormalizationNode,
+|};
+
 export type NormalizationTypeDiscriminator = {|
   +kind: 'TypeDiscriminator',
   +abstractKey: string,
@@ -155,10 +166,12 @@ export type NormalizationTypeDiscriminator = {|
 
 export type NormalizationSelection =
   | NormalizationCondition
+  | NormalizationClientComponent
   | NormalizationClientExtension
   | NormalizationDefer
   | NormalizationField
   | NormalizationFlightField
+  | NormalizationFragmentSpread
   | NormalizationHandle
   | NormalizationInlineFragment
   | NormalizationModuleImport

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

@@ -68,6 +68,7 @@ export type GeneratedNode =
 
 const RelayConcreteNode = {
   CONDITION: 'Condition',
+  CLIENT_COMPONENT: 'ClientComponent',
   CLIENT_EXTENSION: 'ClientExtension',
   DEFER: 'Defer',
   CONNECTION: 'Connection',
@@ -83,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,23 +19,33 @@ 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,
   ENABLE_LOAD_QUERY_REQUEST_DEDUPING: boolean,
+  ENABLE_DO_NOT_WRAP_LIVE_QUERY: boolean,
+  ENABLE_NOTIFY_SUBSCRIPTION: boolean,
+  ENABLE_UNIQUE_SUBSCRIPTION_ROOT: boolean,
+  ENABLE_BATCHED_STORE_UPDATES: boolean,
 |};
 
 const RelayFeatureFlags: FeatureFlags = {
   ENABLE_VARIABLE_CONNECTION_KEY: false,
-  ENABLE_PARTIAL_RENDERING_DEFAULT: false,
-  ENABLE_RELAY_CONTAINERS_SUSPENSE: false,
+  ENABLE_PARTIAL_RENDERING_DEFAULT: true,
+  ENABLE_RELAY_CONTAINERS_SUSPENSE: true,
   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,
   ENABLE_LOAD_QUERY_REQUEST_DEDUPING: true,
+  ENABLE_DO_NOT_WRAP_LIVE_QUERY: false,
+  ENABLE_NOTIFY_SUBSCRIPTION: false,
+  ENABLE_UNIQUE_SUBSCRIPTION_ROOT: false,
+  ENABLE_BATCHED_STORE_UPDATES: false,
 };
 
 module.exports = RelayFeatureFlags;