relay-runtime 20.1.1 → 21.0.0

package/store/observeQueryExperimental.js.flow

@@ -32,7 +32,7 @@ const {createOperationDescriptor} = require('./RelayModernOperationDescriptor');
  * This feature is still experimental and does not properly handle some resolver
  * features such as client-to-server edges.
  */
-function observeQuery<TVariables: Variables, TData>(
+function observeQuery<TVariables extends Variables, TData>(
   environment: IEnvironment,
   gqlQuery: Query<TVariables, TData>,
   variables: TVariables,
@@ -43,15 +43,15 @@ function observeQuery<TVariables: Variables, TData>(
   );
 
   const rootFragmentRef: $FlowFixMe = {
-    __id: operation.fragment.dataID,
+    __fragmentOwner: operation.request,
     __fragments: {
       [operation.fragment.node.name]: operation.request.variables,
     },
-    __fragmentOwner: operation.request,
+    __id: operation.fragment.dataID,
   };
 
-  const fragmentNode: Fragment<$FlowFixMe, TData> = (operation.request.node
-    .fragment: $FlowFixMe);
+  const fragmentNode: Fragment<$FlowFixMe, TData> = operation.request.node
+    .fragment as $FlowFixMe;
 
   return observeFragment(environment, fragmentNode, rootFragmentRef);
 }

package/store/readInlineData.js.flow

@@ -27,19 +27,19 @@ type HasSpread<TFragmentType> = {
 /**
  * Reads an @inline data fragment that was spread into the parent fragment.
  */
-declare function readInlineData<TFragmentType: FragmentType, TData>(
+declare function readInlineData<TFragmentType extends FragmentType, TData>(
   fragment: InlineFragment<TFragmentType, TData>,
   key: HasSpread<TFragmentType>,
 ): TData;
-declare function readInlineData<TFragmentType: FragmentType, TData>(
+declare function readInlineData<TFragmentType extends FragmentType, TData>(
   fragment: InlineFragment<TFragmentType, TData>,
   key: ?HasSpread<TFragmentType>,
 ): ?TData;
 
 function readInlineData(
   fragment: GraphQLTaggedNode,
-  fragmentRef: mixed,
-): mixed {
+  fragmentRef: unknown,
+): unknown {
   const inlineDataFragment = getInlineDataFragment(fragment);
   if (fragmentRef == null) {
     return fragmentRef;

package/store/waitForFragmentExperimental.js.flow

@@ -33,12 +33,12 @@ const {observeFragment} = require('./observeFragmentExperimental');
  * you might choose to @defer a fragment that you only need to access inside an
  * event handler and then await its value inside the handler if/when it is triggered.
  */
-async function waitForFragmentData<TFragmentType: FragmentType, TData>(
+async function waitForFragmentData<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
   fragmentRef:
     | HasSpread<TFragmentType>
-    | $ReadOnlyArray<HasSpread<TFragmentType>>,
+    | ReadonlyArray<HasSpread<TFragmentType>>,
 ): Promise<TData> {
   let subscription: ?Subscription;
 
@@ -60,7 +60,7 @@ async function waitForFragmentData<TFragmentType: FragmentType, TData>(
     });
     subscription?.unsubscribe();
     return data;
-  } catch (e: mixed) {
+  } catch (e: unknown) {
     subscription?.unsubscribe();
     throw e;
   }

package/subscription/requestSubscription.js.flow

@@ -42,18 +42,18 @@ export type SubscriptionParameters = {
  * type information.
  */
 export type GraphQLSubscriptionConfig<TVariables, TData, TRawResponse> =
-  $ReadOnly<{
+  Readonly<{
     configs?: Array<DeclarativeMutationConfig>,
     cacheConfig?: CacheConfig,
     subscription: GraphQLSubscription<TVariables, TData, TRawResponse>,
-    variables: TVariables,
+    variables: NoInfer<TVariables>,
     onCompleted?: ?() => void,
     onError?: ?(error: Error) => void,
     onNext?: ?(response: ?TData) => void,
     updater?: ?SelectorStoreUpdater<TData>,
   }>;
 
-function requestSubscription<TVariables: Variables, TData, TRawResponse>(
+function requestSubscription<TVariables extends Variables, TData, TRawResponse>(
   environment: IEnvironment,
   config: GraphQLSubscriptionConfig<TVariables, TData, TRawResponse>,
 ): Disposable {
@@ -89,6 +89,8 @@ function requestSubscription<TVariables: Variables, TData, TRawResponse>(
       updater,
     })
     .subscribe({
+      complete: onCompleted,
+      error: onError,
       next: responses => {
         if (onNext != null) {
           let selector = operation.fragment;
@@ -107,12 +109,10 @@ function requestSubscription<TVariables: Variables, TData, TRawResponse>(
             );
           }
           const data = environment.lookup(selector).data;
-          // $FlowFixMe[incompatible-cast]
-          onNext((data: TData));
+          // $FlowFixMe[incompatible-type]
+          onNext(data as TData);
         }
       },
-      error: onError,
-      complete: onCompleted,
     });
   return {
     dispose: sub.unsubscribe,

package/util/NormalizationNode.js.flow

@@ -22,13 +22,15 @@ import type {JSResourceReference} from 'JSResourceReference';
 export type NormalizationOperation = {
   +kind: 'Operation',
   +name: string,
-  +argumentDefinitions: $ReadOnlyArray<NormalizationLocalArgumentDefinition>,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +argumentDefinitions: ReadonlyArray<NormalizationLocalArgumentDefinition>,
+  +selections: ReadonlyArray<NormalizationSelection>,
   +clientAbstractTypes?: {
-    +[string]: $ReadOnlyArray<string>,
+    +[string]: ReadonlyArray<string>,
   },
+  +has_server_to_client_resolvers?: boolean,
   +use_exec_time_resolvers?: boolean,
   +exec_time_resolvers_enabled_provider?: ProvidedVariableType,
+  +use_experimental_provider?: ProvidedVariableType,
 };
 
 export type NormalizationHandle =
@@ -39,26 +41,26 @@ export type NormalizationLinkedHandle = {
   +kind: 'LinkedHandle',
   +alias?: ?string,
   +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
   +handle: string,
   +key: string,
   // NOTE: this property is optional because it's expected to be rarely used
   +dynamicKey?: ?NormalizationArgument,
-  +filters?: ?$ReadOnlyArray<string>,
-  +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
+  +filters?: ?ReadonlyArray<string>,
+  +handleArgs?: ReadonlyArray<NormalizationArgument>,
 };
 
 export type NormalizationScalarHandle = {
   +kind: 'ScalarHandle',
   +alias?: ?string,
   +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
   +handle: string,
   +key: string,
   // NOTE: this property is optional because it's expected to be rarely used
   +dynamicKey?: ?NormalizationArgument,
-  +filters?: ?$ReadOnlyArray<string>,
-  +handleArgs?: $ReadOnlyArray<NormalizationArgument>,
+  +filters?: ?ReadonlyArray<string>,
+  +handleArgs?: ReadonlyArray<NormalizationArgument>,
 };
 
 export type NormalizationArgument =
@@ -71,12 +73,12 @@ export type NormalizationCondition = {
   +kind: 'Condition',
   +passingValue: boolean,
   +condition: string,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationClientExtension = {
   +kind: 'ClientExtension',
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationField =
@@ -87,7 +89,7 @@ export type NormalizationField =
 
 export type NormalizationInlineFragment = {
   +kind: 'InlineFragment',
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +selections: ReadonlyArray<NormalizationSelection>,
   +type: string,
   +abstractKey?: ?string,
 };
@@ -95,7 +97,7 @@ export type NormalizationInlineFragment = {
 export type NormalizationFragmentSpread = {
   +kind: 'FragmentSpread',
   +fragment: NormalizationSplitOperation,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
 };
 
 export type NormalizationLinkedField = {
@@ -103,10 +105,10 @@ export type NormalizationLinkedField = {
   +alias?: ?string,
   +name: string,
   +storageKey?: ?string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
   +concreteType?: ?string,
   +plural: boolean,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationActorChange = {
@@ -115,15 +117,15 @@ export type NormalizationActorChange = {
 };
 
 export type NormalizationModuleImport = {
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
   +kind: 'ModuleImport',
   +documentName: string,
   +fragmentPropName: string,
   +fragmentName: string,
   +componentModuleProvider?: () =>
-    | mixed
-    | Promise<mixed>
-    | JSResourceReference<mixed>,
+    | unknown
+    | Promise<unknown>
+    | JSResourceReference<unknown>,
   +operationModuleProvider?: () =>
     | NormalizationRootNode
     | Promise<NormalizationRootNode>
@@ -133,20 +135,20 @@ export type NormalizationModuleImport = {
 export type NormalizationListValueArgument = {
   +kind: 'ListValue',
   +name: string,
-  +items: $ReadOnlyArray<NormalizationArgument | null>,
+  +items: ReadonlyArray<NormalizationArgument | null>,
 };
 
 export type NormalizationLiteralArgument = {
   +kind: 'Literal',
   +name: string,
   +type?: ?string,
-  +value: mixed,
+  +value: unknown,
 };
 
 export type NormalizationLocalArgumentDefinition = {
   +kind: 'LocalArgument',
   +name: string,
-  +defaultValue: mixed,
+  +defaultValue: unknown,
 };
 
 export type NormalizationNode =
@@ -163,7 +165,7 @@ export type NormalizationScalarField = {
   +kind: 'ScalarField',
   +alias?: ?string,
   +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
   +storageKey?: ?string,
 };
 
@@ -185,7 +187,7 @@ type ResolverData =
 export type NormalizationResolverField = {
   +kind: 'RelayResolver',
   +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
   +fragment?: ?NormalizationInlineFragment,
   +storageKey?: ?string,
   +isOutputType: boolean,
@@ -195,7 +197,7 @@ export type NormalizationResolverField = {
 export type NormalizationLiveResolverField = {
   +kind: 'RelayLiveResolver',
   +name: string,
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
   +fragment?: ?NormalizationInlineFragment,
   +storageKey?: ?string,
   +isOutputType: boolean,
@@ -216,7 +218,7 @@ export type NormalizationClientEdgeToClientObject = {
 };
 
 export type NormalizationClientComponent = {
-  +args?: ?$ReadOnlyArray<NormalizationArgument>,
+  +args?: ?ReadonlyArray<NormalizationArgument>,
   +kind: 'ClientComponent',
   +fragment: NormalizationNode,
 };
@@ -242,25 +244,25 @@ export type NormalizationSelection =
   | NormalizationTypeDiscriminator;
 
 export type NormalizationSplitOperation = {
-  +argumentDefinitions?: $ReadOnlyArray<NormalizationLocalArgumentDefinition>,
+  +argumentDefinitions?: ReadonlyArray<NormalizationLocalArgumentDefinition>,
   +kind: 'SplitOperation',
   +name: string,
-  +metadata?: ?{+[key: string]: mixed, ...},
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +metadata?: ?{+[key: string]: unknown, ...},
+  +selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationStream = {
   +if: string | null,
   +kind: 'Stream',
   +label: string,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationDefer = {
   +if: string | null,
   +kind: 'Defer',
   +label: string,
-  +selections: $ReadOnlyArray<NormalizationSelection>,
+  +selections: ReadonlyArray<NormalizationSelection>,
 };
 
 export type NormalizationVariableArgument = {
@@ -273,7 +275,7 @@ export type NormalizationVariableArgument = {
 export type NormalizationObjectValueArgument = {
   +kind: 'ObjectValue',
   +name: string,
-  +fields: $ReadOnlyArray<NormalizationArgument>,
+  +fields: ReadonlyArray<NormalizationArgument>,
 };
 
 export type NormalizationSelectableNode =

package/util/ReaderNode.js.flow

@@ -19,15 +19,15 @@ import type {JSResourceReference} from 'JSResourceReference';
 export type ReaderFragmentSpread = {
   +kind: 'FragmentSpread',
   +name: string,
-  +args?: ?$ReadOnlyArray<ReaderArgument>,
+  +args?: ?ReadonlyArray<ReaderArgument>,
 };
 
 export type ReaderInlineDataFragmentSpread = {
   +kind: 'InlineDataFragmentSpread',
   +name: string,
-  +selections: $ReadOnlyArray<ReaderSelection>,
-  +args?: ?$ReadOnlyArray<ReaderArgument>,
-  +argumentDefinitions: $ReadOnlyArray<ReaderArgumentDefinition>,
+  +selections: ReadonlyArray<ReaderSelection>,
+  +args?: ?ReadonlyArray<ReaderArgument>,
+  +argumentDefinitions: ReadonlyArray<ReaderArgumentDefinition>,
 };
 
 export type ReaderFragment = {
@@ -36,7 +36,7 @@ export type ReaderFragment = {
   +type: string,
   +abstractKey?: ?string,
   +metadata?: ?{
-    +connection?: $ReadOnlyArray<ConnectionMetadata>,
+    +connection?: ReadonlyArray<ConnectionMetadata>,
     // Indicates if the fragment has been annotated with `@throwOnFieldError`
     +throwOnFieldError?: boolean,
     // Indicates if the fragment has been annotated with `@catch`
@@ -45,9 +45,10 @@ export type ReaderFragment = {
     +mask?: boolean,
     +plural?: boolean,
     +refetch?: ReaderRefetchMetadata,
+    +vultureHash?: string,
   },
-  +argumentDefinitions: $ReadOnlyArray<ReaderArgumentDefinition>,
-  +selections: $ReadOnlyArray<ReaderSelection>,
+  +argumentDefinitions: ReadonlyArray<ReaderArgumentDefinition>,
+  +selections: ReadonlyArray<ReaderSelection>,
 };
 
 // Marker type for a @refetchable fragment
@@ -96,7 +97,7 @@ export type ReaderPaginationMetadata = {
     +count: string,
     +cursor: string,
   } | null,
-  +path: $ReadOnlyArray<string>,
+  +path: ReadonlyArray<string>,
 };
 
 export type ReaderInlineDataFragment = {
@@ -116,12 +117,12 @@ export type ReaderCondition = {
   +kind: 'Condition',
   +passingValue: boolean,
   +condition: string,
-  +selections: $ReadOnlyArray<ReaderSelection>,
+  +selections: ReadonlyArray<ReaderSelection>,
 };
 
 export type ReaderClientExtension = {
   +kind: 'ClientExtension',
-  +selections: $ReadOnlyArray<ReaderSelection>,
+  +selections: ReadonlyArray<ReaderSelection>,
 };
 
 export type ReaderField =
@@ -137,7 +138,7 @@ export type ReaderRootArgument = {
 
 export type ReaderInlineFragment = {
   +kind: 'InlineFragment',
-  +selections: $ReadOnlyArray<ReaderSelection>,
+  +selections: ReadonlyArray<ReaderSelection>,
   +type: ?string,
   +abstractKey?: ?string,
 };
@@ -153,10 +154,10 @@ export type ReaderLinkedField = {
   +alias?: ?string,
   +name: string,
   +storageKey?: ?string,
-  +args?: ?$ReadOnlyArray<ReaderArgument>,
+  +args?: ?ReadonlyArray<ReaderArgument>,
   +concreteType?: ?string,
   +plural: boolean,
-  +selections: $ReadOnlyArray<ReaderSelection>,
+  +selections: ReadonlyArray<ReaderSelection>,
 };
 
 export type ReaderActorChange = {
@@ -164,45 +165,45 @@ export type ReaderActorChange = {
   +alias?: ?string,
   +name: string,
   +storageKey?: ?string,
-  +args?: ?$ReadOnlyArray<ReaderArgument>,
+  +args?: ?ReadonlyArray<ReaderArgument>,
   +fragmentSpread: ReaderFragmentSpread,
 };
 
 export type ReaderModuleImport = {
-  +args?: ?$ReadOnlyArray<ReaderArgument>,
+  +args?: ?ReadonlyArray<ReaderArgument>,
   +kind: 'ModuleImport',
   +documentName: string,
   +fragmentPropName: string,
   +fragmentName: string,
   +componentModuleProvider?: () =>
-    | mixed
-    | Promise<mixed>
-    | JSResourceReference<mixed>,
+    | unknown
+    | Promise<unknown>
+    | JSResourceReference<unknown>,
 };
 
 export type ReaderListValueArgument = {
   +kind: 'ListValue',
   +name: string,
-  +items: $ReadOnlyArray<ReaderArgument | null>,
+  +items: ReadonlyArray<ReaderArgument | null>,
 };
 
 export type ReaderLiteralArgument = {
   +kind: 'Literal',
   +name: string,
   +type?: ?string,
-  +value: mixed,
+  +value: unknown,
 };
 
 export type ReaderLocalArgument = {
   +kind: 'LocalArgument',
   +name: string,
-  +defaultValue: mixed,
+  +defaultValue: unknown,
 };
 
 export type ReaderObjectValueArgument = {
   +kind: 'ObjectValue',
   +name: string,
-  +fields: $ReadOnlyArray<ReaderArgument>,
+  +fields: ReadonlyArray<ReaderArgument>,
 };
 
 export type ReaderNode =
@@ -215,18 +216,18 @@ export type ReaderScalarField = {
   +kind: 'ScalarField',
   +alias?: ?string,
   +name: string,
-  +args?: ?$ReadOnlyArray<ReaderArgument>,
+  +args?: ?ReadonlyArray<ReaderArgument>,
   +storageKey?: ?string,
 };
 
 export type ReaderDefer = {
   +kind: 'Defer',
-  +selections: $ReadOnlyArray<ReaderSelection>,
+  +selections: ReadonlyArray<ReaderSelection>,
 };
 
 export type ReaderStream = {
   +kind: 'Stream',
-  +selections: $ReadOnlyArray<ReaderSelection>,
+  +selections: ReadonlyArray<ReaderSelection>,
 };
 
 export type RequiredFieldAction = 'NONE' | 'LOG' | 'THROW';
@@ -236,7 +237,7 @@ export type ReaderRequiredField = {
   +field: ReaderField | ReaderClientEdge,
   +action: RequiredFieldAction,
   // TODO: This field is not used any more, we should be able to remove it.
-  +path?: mixed,
+  +path?: unknown,
 };
 
 export type CatchFieldTo = 'RESULT' | 'NULL';
@@ -246,10 +247,10 @@ export type ReaderCatchField = {
   +field: ReaderField | ReaderClientEdge | ReaderAliasedInlineFragmentSpread,
   +to: CatchFieldTo,
   // TODO: This field is not used any more, we should be able to remove it.
-  +path?: mixed,
+  +path?: unknown,
 };
 
-export type ResolverFunction = (...args: Array<any>) => mixed; // flowlint-line unclear-type:off
+export type ResolverFunction = (...args: Array<any>) => unknown; // flowlint-line unclear-type:off
 // With ES6 imports, a resolver function might be exported under the `default` key.
 export type ResolverModule = ResolverFunction | {default: ResolverFunction};
 
@@ -274,7 +275,7 @@ export type ReaderRelayResolver = {
   +kind: 'RelayResolver',
   +alias?: ?string,
   +name: string,
-  +args?: ?$ReadOnlyArray<ReaderArgument>,
+  +args?: ?ReadonlyArray<ReaderArgument>,
   +fragment?: ?ReaderFragmentSpread,
   +path: string,
   +resolverModule: ResolverModule,
@@ -285,7 +286,7 @@ export type ReaderRelayLiveResolver = {
   +kind: 'RelayLiveResolver',
   +alias?: ?string,
   +name: string,
-  +args?: ?$ReadOnlyArray<ReaderArgument>,
+  +args?: ?ReadonlyArray<ReaderArgument>,
   +fragment?: ?ReaderFragmentSpread,
   +path: string,
   +resolverModule: ResolverModule,
@@ -298,6 +299,7 @@ export type ReaderClientEdgeToClientObject = {
   +modelResolvers: {
     [string]: ReaderRelayResolver | ReaderRelayLiveResolver,
   } | null,
+  +serverObjectOperations?: {[string]: ConcreteRequest} | null,
   +linkedField: ReaderLinkedField,
   +backingField:
     | ReaderRelayResolver

package/util/RelayConcreteNode.js.flow

@@ -39,9 +39,9 @@ export type NormalizationRootNode =
   | ConcreteRequest
   | NormalizationSplitOperation;
 
-export type ProvidedVariableType = {get(): mixed};
+export type ProvidedVariableType = {get(): unknown};
 
-export type ProvidedVariablesType = {+[key: string]: {get(): mixed}};
+export type ProvidedVariablesType = {+[key: string]: {get(): unknown}};
 
 /**
  * Contains the parameters required for executing a GraphQL request.
@@ -57,7 +57,7 @@ export type RequestParameters =
       +name: string,
       +operationKind: 'mutation' | 'query' | 'subscription',
       +providedVariables?: ProvidedVariablesType,
-      +metadata: {[key: string]: mixed, ...},
+      +metadata: {[key: string]: unknown, ...},
     }
   | {
       +cacheID: string,
@@ -67,7 +67,7 @@ export type RequestParameters =
       +name: string,
       +operationKind: 'mutation' | 'query' | 'subscription',
       +providedVariables?: ProvidedVariablesType,
-      +metadata: {[key: string]: mixed, ...},
+      +metadata: {[key: string]: unknown, ...},
     };
 
 export type ClientRequestParameters = {
@@ -78,7 +78,7 @@ export type ClientRequestParameters = {
   +name: string,
   +operationKind: 'query' | 'mutation',
   +providedVariables?: ProvidedVariablesType,
-  +metadata: {[key: string]: mixed, ...},
+  +metadata: {[key: string]: unknown, ...},
 };
 
 export type ClientRequest = {

package/util/RelayError.js.flow

@@ -25,12 +25,15 @@ function createError(
     String(messageParams[index++]),
   );
   const err = new Error(message);
+  // messageParams[2] is the operation name
+  const operation = messageParams[2] ?? null;
   // $FlowFixMe[unsafe-object-assign]
-  const error = Object.assign((err: any), {
+  const error = Object.assign(err as any, {
     name,
     messageFormat,
     messageParams,
     type,
+    operation,
     taalOpcodes: [2, 2], // skip frame (code=2) twice
   });
   // In V8, Error objects keep the closure scope chain alive until the

package/util/RelayFeatureFlags.js.flow

@@ -80,6 +80,22 @@ export type FeatureFlags = {
   //
   // See https://github.com/facebook/relay/issues/4882
   CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: boolean,
+
+  // When enabled, records created for Relay Resolvers will be filtered out
+  // from the store when serializing to JSON.
+  FILTER_OUT_RELAY_RESOLVER_RECORDS: boolean,
+
+  // Reduce the work on store.notify
+  OPTIMIZE_NOTIFY: boolean,
+
+  // Enable per-field subscription granularity on specific records (e.g. client:root).
+  // When enabled, subscriptions reading a field-granular record are only notified
+  // when the specific fields they read have changed, rather than on any change
+  // to the record.
+  ENABLE_FIELD_GRANULAR_NOTIFICATIONS: boolean,
+
+  // Enable logging for reader reading fragment spreads and fragments. Useful for logging unused fragments.
+  ENABLE_READER_FRAGMENTS_LOGGING: boolean,
 };
 
 const RelayFeatureFlags: FeatureFlags = {
@@ -102,13 +118,17 @@ const RelayFeatureFlags: FeatureFlags = {
   PROCESS_OPTIMISTIC_UPDATE_BEFORE_SUBSCRIPTION: false,
   MARK_RESOLVER_VALUES_AS_CLEAN_AFTER_FRAGMENT_REREAD: false,
   ENABLE_CYLE_DETECTION_IN_VARIABLES: false,
-  ENABLE_ACTIVITY_COMPATIBILITY: false,
+  ENABLE_ACTIVITY_COMPATIBILITY: true,
   ENABLE_READ_TIME_RESOLVER_STORAGE_KEY_PREFIX: true,
   ENABLE_USE_PAGINATION_IS_LOADING_FIX: false,
   DISALLOW_NESTED_UPDATES: false,
   ENABLE_TYPENAME_PREFIXED_DATA_ID: false,
   ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false,
   CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: false,
+  FILTER_OUT_RELAY_RESOLVER_RECORDS: false,
+  OPTIMIZE_NOTIFY: false,
+  ENABLE_FIELD_GRANULAR_NOTIFICATIONS: false,
+  ENABLE_READER_FRAGMENTS_LOGGING: false,
 };
 
 module.exports = RelayFeatureFlags;

package/util/RelayProfiler.js.flow

@@ -18,7 +18,7 @@ const profileHandlersByName: {
   [name: EventName]: Array<ProfileHandler>,
 } = {};
 
-const defaultProfiler = {
+const defaultProfiler: {stop: (error?: Error) => void, ...} = {
   stop() {},
 };