relay-runtime 20.1.1 → 21.0.0

package/store/ResolverCache.js.flow

@@ -32,8 +32,8 @@ export type EvaluationResult<T> = {
   error: ?Error,
 };
 
-export type ResolverFragmentResult = $ReadOnly<{
-  data: mixed,
+export type ResolverFragmentResult = Readonly<{
+  data: unknown,
   isMissingData: boolean,
   fieldErrors: ?FieldErrors,
 }>;

package/store/ResolverFragments.js.flow

@@ -52,33 +52,33 @@ function withResolverContext<T>(context: ResolverContext, cb: () => T): T {
 //   - array of nullable if the provided ref type is an array of nullable refs
 
 declare function readFragment<
-  TKey: {+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
+  TKey extends {+$data?: unknown, +$fragmentSpreads: FragmentType, ...},
 >(
   fragmentInput: GraphQLTaggedNode,
   fragmentKey: TKey,
-): $NonMaybeType<TKey['$data']>;
+): NonNullable<TKey['$data']>;
 
 declare function readFragment<
-  TKey: ?{+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
+  TKey extends ?{+$data?: unknown, +$fragmentSpreads: FragmentType, ...},
 >(
   fragmentInput: GraphQLTaggedNode,
   fragmentKey: TKey,
 ): ?TKey?.['$data'];
 
 declare function readFragment<
-  TKey: $ReadOnlyArray<{
-    +$data?: mixed,
+  TKey extends ReadonlyArray<{
+    +$data?: unknown,
     +$fragmentSpreads: FragmentType,
     ...
   }>,
 >(
   fragmentInput: GraphQLTaggedNode,
   fragmentKey: TKey,
-): $NonMaybeType<TKey[number]['$data']>;
+): NonNullable<TKey[number]['$data']>;
 
 declare function readFragment<
-  TKey: ?$ReadOnlyArray<{
-    +$data?: mixed,
+  TKey extends ?ReadonlyArray<{
+    +$data?: unknown,
     +$fragmentSpreads: FragmentType,
     ...
   }>,
@@ -87,7 +87,7 @@ declare function readFragment<
   fragmentKey: TKey,
 ): ?TKey?.[number]['$data'];
 
-declare function readFragment<TKey: FragmentType, TData>(
+declare function readFragment<TKey extends FragmentType, TData>(
   fragmentInput: Fragment<TKey, TData>,
   fragmentKey: TKey,
 ): TData;
@@ -95,7 +95,7 @@ declare function readFragment<TKey: FragmentType, TData>(
 function readFragment(
   fragmentInput: GraphQLTaggedNode,
   fragmentKey: FragmentType,
-): mixed {
+): unknown {
   if (!contextStack.length) {
     throw new Error(
       'readFragment should be called only from within a Relay Resolver function.',
@@ -127,10 +127,10 @@ function readFragment(
   return data;
 }
 
-const RESOLVER_FRAGMENT_ERRORED_SENTINEL: mixed = {};
+const RESOLVER_FRAGMENT_ERRORED_SENTINEL: unknown = {};
 
 module.exports = {
+  RESOLVER_FRAGMENT_ERRORED_SENTINEL,
   readFragment,
   withResolverContext,
-  RESOLVER_FRAGMENT_ERRORED_SENTINEL,
 };

package/store/StoreInspector.js.flow

@@ -13,7 +13,7 @@
 
 import type {IEnvironment, RecordSource} from '../store/RelayStoreTypes';
 
-type InspectFn = (environment: IEnvironment, dataID?: ?string) => mixed;
+type InspectFn = (environment: IEnvironment, dataID?: ?string) => unknown;
 
 let inspect: InspectFn = () => {};
 
@@ -81,8 +81,8 @@ if (__DEV__) {
 
     class RecordEntry {
       +key: string;
-      +value: mixed;
-      constructor(key: string, value: mixed) {
+      +value: unknown;
+      constructor(key: string, value: unknown) {
         this.key = key;
         this.value = value;
       }
@@ -138,14 +138,13 @@ if (__DEV__) {
   const getWrappedRecord = (
     source: RecordSource,
     dataID: string,
-  ): ?{[string]: mixed} => {
+  ): ?{[string]: unknown} => {
     const record = source.get(dataID);
     if (record == null) {
-      // $FlowFixMe[incompatible-return]
+      // $FlowFixMe[incompatible-type]
       return record;
     }
     return new Proxy(
-      // $FlowFixMe: Do not assume that record is an object
       {...record},
       {
         get(target, prop) {
@@ -159,7 +158,7 @@ if (__DEV__) {
               return getWrappedRecord(source, value.__ref);
             }
             if (Array.isArray(value.__refs)) {
-              // $FlowFixMe[incompatible-call]
+              // $FlowFixMe[incompatible-type]
               return value.__refs.map((ref: string) =>
                 getWrappedRecord(source, ref),
               );

package/store/cloneRelayHandleSourceField.js.flow

@@ -32,7 +32,7 @@ const invariant = require('invariant');
  */
 function cloneRelayHandleSourceField(
   handleField: NormalizationLinkedHandle,
-  selections: $ReadOnlyArray<NormalizationSelection>,
+  selections: ReadonlyArray<NormalizationSelection>,
   variables: Variables,
 ): NormalizationLinkedField {
   const sourceField = selections.find(

package/store/cloneRelayScalarHandleSourceField.js.flow

@@ -31,7 +31,7 @@ const invariant = require('invariant');
  */
 function cloneRelayScalarHandleSourceField(
   handleField: NormalizationScalarHandle,
-  selections: $ReadOnlyArray<NormalizationSelection>,
+  selections: ReadonlyArray<NormalizationSelection>,
   variables: Variables,
 ): NormalizationScalarField {
   const sourceField = selections.find(

package/store/createRelayContext.js.flow

@@ -19,7 +19,7 @@ const invariant = require('invariant');
 
 // Ideally, we'd just import the type of the react module, but this causes Flow
 // problems.
-type React = $ReadOnly<{
+type React = Readonly<{
   createContext: createContext<RelayContext | null>,
   version: string,
   ...

package/store/createRelayLoggingContext.js.flow

@@ -18,16 +18,16 @@ const invariant = require('invariant');
 
 // Ideally, we'd just import the type of the react module, but this causes Flow
 // problems.
-type React = $ReadOnly<{
-  createContext: createContext<mixed | null>,
+type React = Readonly<{
+  createContext: createContext<unknown | null>,
   version: string,
   ...
 }>;
 
-let relayLoggingContext: ?Context<mixed | null>;
+let relayLoggingContext: ?Context<unknown | null>;
 let firstReact: ?React;
 
-function createRelayLoggingContext(react: React): Context<mixed | null> {
+function createRelayLoggingContext(react: React): Context<unknown | null> {
   if (!relayLoggingContext) {
     relayLoggingContext = react.createContext(null);
     if (__DEV__) {

package/store/defaultGetDataID.js.flow

@@ -14,9 +14,9 @@
 const {VIEWER_ID, VIEWER_TYPE} = require('./ViewerPattern');
 
 function defaultGetDataID(
-  fieldValue: {+[string]: mixed},
+  fieldValue: {+[string]: unknown},
   typeName: string,
-): mixed {
+): unknown {
   if (typeName === VIEWER_TYPE) {
     return fieldValue.id == null ? VIEWER_ID : fieldValue.id;
   }

package/store/isRelayModernEnvironment.js.flow

@@ -19,8 +19,10 @@
  * aid in module tree-shaking to avoid requiring all of RelayRuntime just to
  * detect its environment.
  */
-function isRelayModernEnvironment(environment: mixed): boolean {
-  return Boolean(environment && (environment: any)['@@RelayModernEnvironment']);
+function isRelayModernEnvironment(environment: unknown): boolean {
+  return Boolean(
+    environment && (environment as any)['@@RelayModernEnvironment'],
+  );
 }
 
 module.exports = isRelayModernEnvironment;

package/store/live-resolvers/LiveResolverCache.js.flow

@@ -46,6 +46,7 @@ const {
   RELAY_RESOLVER_ERROR_KEY,
   RELAY_RESOLVER_INVALIDATION_KEY,
   RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,
+  RELAY_RESOLVER_RECORD_TYPENAME,
   RELAY_RESOLVER_SNAPSHOT_KEY,
   RELAY_RESOLVER_VALUE_KEY,
   getReadTimeResolverStorageKey,
@@ -63,7 +64,6 @@ const RELAY_RESOLVER_LIVE_STATE_SUBSCRIPTION_KEY =
   '__resolverLiveStateSubscription';
 const RELAY_RESOLVER_LIVE_STATE_VALUE = '__resolverLiveStateValue';
 const RELAY_RESOLVER_LIVE_STATE_DIRTY = '__resolverLiveStateDirty';
-const RELAY_RESOLVER_RECORD_TYPENAME = '__RELAY_RESOLVER__';
 const MODEL_PROPERTY_NAME = '__relay_model_instance';
 
 /**
@@ -181,7 +181,7 @@ class LiveResolverCache implements ResolverCache {
             evaluationResult.error == null,
             'Did not expect resolver to have both a value and an error.',
           );
-          const liveState: LiveState<mixed> =
+          const liveState: LiveState<unknown> =
             // $FlowFixMe[incompatible-type] - casting mixed
             evaluationResult.resolverResult;
           updatedDataIDs = this._setLiveStateValue(
@@ -261,7 +261,7 @@ class LiveResolverCache implements ResolverCache {
       linkedID = linkedID ?? generateClientID(recordID, storageKey);
       linkedRecord = RelayModernRecord.clone(linkedRecord);
       // $FlowFixMe[incompatible-type] - casting mixed
-      const liveState: LiveState<mixed> = RelayModernRecord.getValue(
+      const liveState: LiveState<unknown> = RelayModernRecord.getValue(
         linkedRecord,
         RELAY_RESOLVER_LIVE_STATE_VALUE,
       );
@@ -327,7 +327,7 @@ class LiveResolverCache implements ResolverCache {
     );
 
     // $FlowFixMe[incompatible-type] - casting mixed
-    const liveState: LiveState<mixed> = RelayModernRecord.getValue(
+    const liveState: LiveState<unknown> = RelayModernRecord.getValue(
       liveStateRecord,
       RELAY_RESOLVER_LIVE_STATE_VALUE,
     );
@@ -345,7 +345,7 @@ class LiveResolverCache implements ResolverCache {
   _setLiveStateValue(
     linkedRecord: Record,
     linkedID: DataID,
-    liveState: LiveState<mixed>,
+    liveState: LiveState<unknown>,
     field: ReaderRelayLiveResolver,
     variables: Variables,
   ): DataIDSet | null {
@@ -474,14 +474,39 @@ class LiveResolverCache implements ResolverCache {
     }
   }
 
+  // Returns true if source is published
+  batchLiveStateUpdatesWithoutNotify(callback: () => void): boolean {
+    invariant(
+      !this._handlingBatch,
+      'Unexpected nested call to batchLiveStateUpdates.',
+    );
+    this._handlingBatch = true;
+    try {
+      callback();
+    } finally {
+      const shouldPublish = this._liveResolverBatchRecordSource != null;
+      // We lazily create the record source. If one has not been created, there
+      // is nothing to publish.
+      if (shouldPublish) {
+        // $FlowFixMe[incompatible-type]  Null checked
+        this._store.publish(this._liveResolverBatchRecordSource);
+      }
+
+      // Reset batched state.
+      this._liveResolverBatchRecordSource = null;
+      this._handlingBatch = false;
+      return shouldPublish;
+    }
+  }
+
   _setLiveResolverValue(
     resolverRecord: Record,
-    liveValue: LiveState<mixed>,
+    liveValue: LiveState<unknown>,
     field: ReaderRelayResolver | ReaderRelayLiveResolver,
     variables: Variables,
   ): DataIDSet | null {
-    let value: null | mixed = null;
-    let resolverError: null | mixed = null;
+    let value: null | unknown = null;
+    let resolverError: null | unknown = null;
     try {
       value = liveValue.read();
     } catch (e) {
@@ -498,7 +523,7 @@ class LiveResolverCache implements ResolverCache {
 
   _setResolverValue(
     resolverRecord: Record,
-    value: mixed,
+    value: unknown,
     field: ReaderRelayResolver | ReaderRelayLiveResolver,
     variables: Variables,
   ): DataIDSet | null {
@@ -623,13 +648,23 @@ class LiveResolverCache implements ResolverCache {
       );
     } else {
       shallowFreeze(value);
-      // For "classic" resolvers (or if the value is nullish), we are just setting their
-      // value as is.
+
+      // For "classic" resolvers (or if the value is nullish/suspense), we are
+      // set their value...
       RelayModernRecord.setValue(
         resolverRecord,
         RELAY_RESOLVER_VALUE_KEY,
         value,
       );
+
+      // ...and clear the output type record IDs, if any since a resolver must
+      // be an output type resolver with a non-suspended, non-null value to
+      // refernce any output type record ids.
+      RelayModernRecord.setValue(
+        resolverRecord,
+        RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,
+        new Set(),
+      );
     }
 
     return updatedDataIDs;
@@ -639,7 +674,7 @@ class LiveResolverCache implements ResolverCache {
     this._store.__notifyUpdatedSubscribers(updatedDataIDs);
   }
 
-  _getResolverValue(resolverRecord: Record): mixed {
+  _getResolverValue(resolverRecord: Record): unknown {
     return RelayModernRecord.getValue(resolverRecord, RELAY_RESOLVER_VALUE_KEY);
   }
 
@@ -659,9 +694,9 @@ class LiveResolverCache implements ResolverCache {
       const recordID: string = recordsToVisit.pop();
       visited.add(recordID);
 
-      // $FlowFixMe[incompatible-call]
+      // $FlowFixMe[incompatible-type]
       updatedDataIDs.add(recordID);
-      // $FlowFixMe[incompatible-call]
+      // $FlowFixMe[incompatible-type]
       const fragmentSet = this._recordIDToResolverIDs.get(recordID);
       if (fragmentSet == null) {
         continue;
@@ -737,7 +772,7 @@ class LiveResolverCache implements ResolverCache {
   // containing only "weak" records.
   _normalizeOutputTypeValue(
     outputTypeDataID: DataID,
-    value: {+[key: string]: mixed},
+    value: {+[key: string]: unknown},
     variables: Variables,
     normalizationInfo: ResolverNormalizationInfo,
     fieldPath: Array<string>,
@@ -788,7 +823,7 @@ class LiveResolverCache implements ResolverCache {
         return source;
       }
       default:
-        (normalizationInfo.kind: empty);
+        normalizationInfo.kind as empty;
         invariant(
           false,
           'LiveResolverCache: Unexpected normalization info kind `%s`.',
@@ -846,7 +881,7 @@ class LiveResolverCache implements ResolverCache {
 function updateCurrentSource(
   currentSource: MutableRecordSource,
   nextSource: RecordSource,
-  prevOutputTypeRecordIDs: ?$ReadOnlySet<DataID>,
+  prevOutputTypeRecordIDs: ?ReadonlySet<DataID>,
 ): DataIDSet {
   const updatedDataIDs = new Set<DataID>();
 
@@ -944,7 +979,7 @@ function markInvalidatedLinkedResolverRecords(
 
 function unsubscribeFromLiveResolverRecordsImpl(
   recordSource: RecordSource,
-  invalidatedDataIDs: $ReadOnlySet<DataID>,
+  invalidatedDataIDs: ReadonlySet<DataID>,
 ): void {
   if (invalidatedDataIDs.size === 0) {
     return;
@@ -999,7 +1034,7 @@ function getConcreteTypename(
   const typename =
     normalizationInfo.concreteType ??
     // $FlowFixMe[prop-missing]
-    (currentValue.__typename: string);
+    (currentValue.__typename as string);
   invariant(
     typename != null,
     'normalizationInfo.concreteType should not be null, or the value returned from the resolver should include a __typename field, ' +
@@ -1010,6 +1045,6 @@ function getConcreteTypename(
 
 module.exports = {
   LiveResolverCache,
-  getUpdatedDataIDs,
   RELAY_RESOLVER_LIVE_STATE_SUBSCRIPTION_KEY,
+  getUpdatedDataIDs,
 };

package/store/live-resolvers/LiveResolverSuspenseSentinel.js.flow

@@ -11,16 +11,16 @@
 
 'use strict';
 
-const LIVE_RESOLVER_SUSPENSE_SENTINEL: mixed = Object.freeze({
+const LIVE_RESOLVER_SUSPENSE_SENTINEL: unknown = Object.freeze({
   __LIVE_RESOLVER_SUSPENSE_SENTINEL: true,
 });
 
 function suspenseSentinel(): empty {
-  // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[incompatible-type]
   return LIVE_RESOLVER_SUSPENSE_SENTINEL;
 }
 
-function isSuspenseSentinel(value: mixed): boolean {
+function isSuspenseSentinel(value: unknown): boolean {
   return value === LIVE_RESOLVER_SUSPENSE_SENTINEL;
 }
 

package/store/live-resolvers/getOutputTypeRecordIDs.js.flow

@@ -18,7 +18,7 @@ const RelayModernRecord = require('../RelayModernRecord');
 const {RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS} = require('../RelayStoreUtils');
 const invariant = require('invariant');
 
-function getOutputTypeRecordIDs(record: Record): $ReadOnlySet<DataID> | null {
+function getOutputTypeRecordIDs(record: Record): ReadonlySet<DataID> | null {
   const maybeOutputTypeRecordIDs = RelayModernRecord.getValue(
     record,
     RELAY_RESOLVER_OUTPUT_TYPE_RECORD_IDS,

package/store/live-resolvers/isLiveStateValue.js.flow

@@ -13,9 +13,9 @@
 
 import type {LiveState} from '../RelayStoreTypes';
 
-declare function isLiveStateValue<T, U = LiveState<T>>(v: mixed): v is U;
+declare function isLiveStateValue<T, U = LiveState<T>>(v: unknown): v is U;
 
-function isLiveStateValue(v: mixed) {
+function isLiveStateValue(v: unknown) {
   return (
     v != null &&
     typeof v === 'object' &&

package/store/live-resolvers/resolverDataInjector.js.flow

@@ -17,7 +17,7 @@ import type {FragmentType, ResolverContext} from '../RelayStoreTypes';
 const {readFragment} = require('../ResolverFragments');
 const invariant = require('invariant');
 
-type ResolverFn = ($FlowFixMe, ?$FlowFixMe, ResolverContext) => mixed;
+type ResolverFn = ($FlowFixMe, ?$FlowFixMe, ResolverContext) => unknown;
 
 /**
  *
@@ -31,20 +31,23 @@ type ResolverFn = ($FlowFixMe, ?$FlowFixMe, ResolverContext) => mixed;
  * This will not call the `resolverFn` if the fragment data for it is null/undefined.
  * The the compiler generates calls to this function, ensuring the correct set of arguments.
  */
-function resolverDataInjector<TFragmentType: FragmentType, TData: ?{...}>(
+function resolverDataInjector<
+  TFragmentType extends FragmentType,
+  TData extends ?{...},
+>(
   fragment: Fragment<TFragmentType, TData>,
   // Resolvers have their own type assertions, we don't want to confuse users
   // with a type error in their generated code at this point.
   _resolverFn: $FlowFixMe,
   fieldName?: string,
   isRequiredField?: boolean,
-): (fragmentKey: TFragmentType, args: mixed) => mixed {
+): (fragmentKey: TFragmentType, args: unknown) => unknown {
   const resolverFn: ResolverFn = _resolverFn;
   return (
     fragmentKey: TFragmentType,
-    args: mixed,
+    args: unknown,
     resolverContext: ResolverContext,
-  ): mixed => {
+  ): unknown => {
     const data = readFragment(fragment, fragmentKey);
     if (fieldName != null) {
       if (data == null) {

package/store/observeFragmentExperimental.js.flow

@@ -9,7 +9,11 @@
  * @oncall relay
  */
 
-import type {PluralReaderSelector, RequestDescriptor} from './RelayStoreTypes';
+import type {
+  PluralReaderSelector,
+  ReaderSelector,
+  RequestDescriptor,
+} from './RelayStoreTypes';
 import type {
   Fragment,
   FragmentType,
@@ -59,12 +63,12 @@ export type HasSpread<TFragmentType> = {
  * 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;
 
@@ -86,18 +90,18 @@ async function waitForFragmentData<TFragmentType: FragmentType, TData>(
     });
     subscription?.unsubscribe();
     return data;
-  } catch (e: mixed) {
+  } catch (e: unknown) {
     subscription?.unsubscribe();
     throw e;
   }
 }
 
-declare function observeFragment<TFragmentType: FragmentType, TData>(
+declare function observeFragment<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
   fragmentRef:
     | HasSpread<TFragmentType>
-    | $ReadOnlyArray<HasSpread<TFragmentType>>,
+    | ReadonlyArray<HasSpread<TFragmentType>>,
 ): Observable<FragmentState<TData>>;
 
 /**
@@ -112,25 +116,28 @@ declare function observeFragment<TFragmentType: FragmentType, TData>(
  *  a field error due to @required(action: THROW) or @throwOnFieldError
  * - 'loading': The fragment is still in flight and is still expected to resolver.
  */
-function observeFragment<TFragmentType: FragmentType, TData>(
+function observeFragment<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragment: Fragment<TFragmentType, TData>,
-  fragmentRef: mixed,
-): mixed {
+  fragmentRef: unknown,
+): unknown {
   const fragmentNode = getFragment(fragment);
   const fragmentSelector = getSelector(fragmentNode, fragmentRef);
+
+  invariant(fragmentSelector != null, 'Expected a selector, got null.');
+
   invariant(
-    fragmentNode.metadata?.hasClientEdges == null,
+    fragmentNode.metadata?.hasClientEdges == null ||
+      fragmentSelectorUsesExecTimeResolver(fragmentSelector),
     "Client edges aren't supported yet.",
   );
-  invariant(fragmentSelector != null, 'Expected a selector, got null.');
   switch (fragmentSelector.kind) {
     case 'SingularReaderSelector':
       return observeSingularSelector(environment, fragment, fragmentSelector);
     case 'PluralReaderSelector': {
       return observePluralSelector(
         environment,
-        (fragment: $FlowFixMe),
+        fragment as $FlowFixMe,
         fragmentSelector,
       );
     }
@@ -138,7 +145,29 @@ function observeFragment<TFragmentType: FragmentType, TData>(
   invariant(false, 'Unsupported fragment selector kind');
 }
 
-function observeSingularSelector<TFragmentType: FragmentType, TData>(
+function fragmentSelectorUsesExecTimeResolver(
+  fragmentSelector: ReaderSelector,
+) {
+  switch (fragmentSelector?.kind) {
+    case 'SingularReaderSelector':
+      return (
+        (fragmentSelector.owner.node.operation?.use_exec_time_resolvers ??
+          fragmentSelector.owner.node.operation?.exec_time_resolvers_enabled_provider?.get()) ===
+        true
+      );
+    case 'PluralReaderSelector': {
+      return fragmentSelector.selectors?.every(
+        selector =>
+          (selector.owner.node.operation.use_exec_time_resolvers ??
+            selector.owner.node.operation?.exec_time_resolvers_enabled_provider?.get()) ===
+          true,
+      );
+    }
+  }
+  return false;
+}
+
+function observeSingularSelector<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
   fragmentSelector: SingularReaderSelector,
@@ -171,8 +200,8 @@ function observeSingularSelector<TFragmentType: FragmentType, TData>(
 }
 
 function observePluralSelector<
-  TFragmentType: FragmentType,
-  TData: Array<mixed>,
+  TFragmentType extends FragmentType,
+  TData extends Array<unknown>,
 >(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
@@ -193,7 +222,7 @@ function observePluralSelector<
       ),
     );
 
-    sink.next((mergeFragmentStates(states): $FlowFixMe));
+    sink.next(mergeFragmentStates(states) as $FlowFixMe);
 
     const subscriptions = snapshots.map((snapshot, index) =>
       environment.subscribe(snapshot, latestSnapshot => {
@@ -205,7 +234,7 @@ function observePluralSelector<
         );
         // This doesn't batch updates, so it will notify the subscriber multiple times
         // if a store update impacting multiple items in the list is published.
-        sink.next((mergeFragmentStates(states): $FlowFixMe));
+        sink.next(mergeFragmentStates(states) as $FlowFixMe);
       }),
     );
 
@@ -213,7 +242,7 @@ function observePluralSelector<
   });
 }
 
-function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
+function snapshotToFragmentState<TFragmentType extends FragmentType, TData>(
   environment: IEnvironment,
   fragmentNode: Fragment<TFragmentType, TData>,
   owner: RequestDescriptor,
@@ -266,11 +295,11 @@ function snapshotToFragmentState<TFragmentType: FragmentType, TData>(
 
   invariant(snapshot.data != null, 'Expected data to be non-null.');
 
-  return {state: 'ok', value: (snapshot.data: $FlowFixMe)};
+  return {state: 'ok', value: snapshot.data as $FlowFixMe};
 }
 
 function mergeFragmentStates<T>(
-  states: $ReadOnlyArray<FragmentState<T>>,
+  states: ReadonlyArray<FragmentState<T>>,
 ): FragmentState<Array<T>> {
   const value = [];
   for (const state of states) {