relay-runtime 20.1.0 → 21.0.0

package/store/OperationExecutor.js.flow

@@ -71,7 +71,12 @@ const {ROOT_TYPE, TYPENAME_KEY, getStorageKey} = require('./RelayStoreUtils');
 const invariant = require('invariant');
 const warning = require('warning');
 
-export type ExecuteConfig<TMutation: MutationParameters> = {
+// A network response OR a pre-normalized payload from the network layer.
+// RelayObservable<+T> is covariant, so Observable<GraphQLResponse> is
+// assignable to Observable<NetworkResponse> automatically.
+type NetworkResponse = GraphQLResponse | RelayResponsePayload;
+
+export type ExecuteConfig<TMutation extends MutationParameters> = {
   +actorIdentifier: ActorIdentifier,
   +getDataID: GetDataID,
   +getPublishQueue: (actorIdentifier: ActorIdentifier) => PublishQueue,
@@ -86,8 +91,9 @@ export type ExecuteConfig<TMutation: MutationParameters> = {
   +scheduler?: ?TaskScheduler,
   +shouldProcessClientComponents?: ?boolean,
   +sink: Sink<GraphQLResponse>,
-  +source: RelayObservable<GraphQLResponse>,
+  +source: RelayObservable<NetworkResponse>,
   +treatMissingFieldsAsNull: boolean,
+  +deferDeduplicatedFields: boolean,
   +updater?: ?SelectorStoreUpdater<TMutation['response']>,
   +log: LogFunction,
 };
@@ -108,11 +114,11 @@ type IncrementalResults =
 
 type IncrementalGraphQLResponse = {
   label: string,
-  path: $ReadOnlyArray<mixed>,
+  path: ReadonlyArray<unknown>,
   response: GraphQLResponseWithData,
 };
 
-function execute<TMutation: MutationParameters>(
+function execute<TMutation extends MutationParameters>(
   config: ExecuteConfig<TMutation>,
 ): Executor<TMutation> {
   return new Executor(config);
@@ -123,10 +129,11 @@ function execute<TMutation: MutationParameters>(
  * including optimistic payloads, standard payloads, resolution of match
  * dependencies, etc.
  */
-class Executor<TMutation: MutationParameters> {
+class Executor<TMutation extends MutationParameters> {
   _actorIdentifier: ActorIdentifier;
   _getDataID: GetDataID;
   _treatMissingFieldsAsNull: boolean;
+  _deferDeduplicatedFields: boolean;
   _incrementalPayloadsPending: boolean;
   _incrementalResults: Map<Label, Map<PathKey, IncrementalResults>>;
   _log: LogFunction;
@@ -160,6 +167,7 @@ class Executor<TMutation: MutationParameters> {
   +_seenActors: Set<ActorIdentifier>;
   _normalizeResponse: NormalizeResponseFunction;
   _execTimeResolverResponseComplete: boolean;
+  _isClientQuery: boolean;
 
   constructor({
     actorIdentifier,
@@ -177,6 +185,7 @@ class Executor<TMutation: MutationParameters> {
     sink,
     source,
     treatMissingFieldsAsNull,
+    deferDeduplicatedFields,
     updater,
     log,
     normalizeResponse,
@@ -184,6 +193,7 @@ class Executor<TMutation: MutationParameters> {
     this._actorIdentifier = actorIdentifier;
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
+    this._deferDeduplicatedFields = deferDeduplicatedFields;
     this._incrementalPayloadsPending = false;
     this._incrementalResults = new Map();
     this._log = log;
@@ -218,6 +228,9 @@ class Executor<TMutation: MutationParameters> {
     this._seenActors = new Set();
     this._completeFns = [];
     this._normalizeResponse = normalizeResponse;
+    this._isClientQuery =
+      this._operation.request.node.params.id == null &&
+      this._operation.request.node.params.text == null;
 
     const id = this._nextSubscriptionId++;
 
@@ -246,17 +259,17 @@ class Executor<TMutation: MutationParameters> {
       start: subscription => {
         this._start(id, subscription);
         this._log({
-          name: 'execute.start',
+          cacheConfig: this._operation.request.cacheConfig ?? {},
           executeId: this._executeId,
+          name: 'execute.start',
           params: this._operation.request.node.params,
           variables: this._operation.request.variables,
-          cacheConfig: this._operation.request.cacheConfig ?? {},
         });
       },
       unsubscribe: () => {
         this._log({
-          name: 'execute.unsubscribe',
           executeId: this._executeId,
+          name: 'execute.unsubscribe',
         });
       },
     });
@@ -331,7 +344,7 @@ class Executor<TMutation: MutationParameters> {
         break;
       }
       default:
-        (this._state: empty);
+        this._state as empty;
         invariant(false, 'OperationExecutor: invalid executor state.');
     }
     this._operationExecutions.set(
@@ -370,8 +383,8 @@ class Executor<TMutation: MutationParameters> {
       this.cancel();
       this._sink.complete();
       this._log({
-        name: 'execute.complete',
         executeId: this._executeId,
+        name: 'execute.complete',
       });
     }
   }
@@ -380,9 +393,9 @@ class Executor<TMutation: MutationParameters> {
     this.cancel();
     this._sink.error(error);
     this._log({
-      name: 'execute.error',
-      executeId: this._executeId,
       error,
+      executeId: this._executeId,
+      name: 'execute.error',
     });
   }
 
@@ -391,30 +404,48 @@ class Executor<TMutation: MutationParameters> {
     this._updateActiveState();
   }
 
-  // Handle a raw GraphQL response.
-  _next(_id: number, response: GraphQLResponse): void {
+  // Handle a raw GraphQL response or a pre-normalized payload from the
+  // network layer. Pre-normalized payloads bypass the normal GraphQL pipeline.
+  _next(_id: number, response: NetworkResponse): void {
     const priority = this._state === 'loading_incremental' ? 'low' : 'default';
     this._schedule(() => {
+      // Pre-normalized payloads from the network layer have isPreNormalized
+      // set by NormalizationEngine. Route them to a dedicated handler that
+      // commits directly to the store, bypassing normalizeResponse().
+      if (
+        !Array.isArray(response) &&
+        // $FlowFixMe[prop-missing] isPreNormalized exists on RelayResponsePayload branch
+        response.isPreNormalized === true
+      ) {
+        // $FlowFixMe[incompatible-type] narrowed by isPreNormalized check
+        this._handlePreNormalizedPayload(response);
+        return;
+      }
+      // After the pre-normalized early return, response is a standard
+      // GraphQLResponse (Flow cannot narrow this automatically because
+      // isPreNormalized is optional, so we cast once here at the boundary).
+      // $FlowFixMe[incompatible-type] narrowed by isPreNormalized check above
+      const graphQLResponse: GraphQLResponse = response;
       this._log({
-        name: 'execute.next.start',
         executeId: this._executeId,
-        response,
+        name: 'execute.next.start',
         operation: this._operation,
+        response: graphQLResponse,
       });
-      this._handleNext(response);
+      this._handleNext(graphQLResponse);
       this._maybeCompleteSubscriptionOperationTracking();
       this._log({
-        name: 'execute.next.end',
         executeId: this._executeId,
-        response,
+        name: 'execute.next.end',
         operation: this._operation,
+        response: graphQLResponse,
       });
     }, priority);
   }
 
   _handleErrorResponse(
-    responses: $ReadOnlyArray<GraphQLSingularResponse>,
-  ): $ReadOnlyArray<GraphQLResponseWithData> {
+    responses: ReadonlyArray<GraphQLSingularResponse>,
+  ): ReadonlyArray<GraphQLResponseWithData> {
     const results = [];
     responses.forEach(response => {
       if (
@@ -442,7 +473,7 @@ class Executor<TMutation: MutationParameters> {
             messages +
             '\n\nSee the error `source` property for more information.',
         );
-        (error: $FlowFixMe).source = {
+        (error as $FlowFixMe).source = {
           errors,
           operation: this._operation.request.node,
           variables: this._operation.request.variables,
@@ -453,7 +484,7 @@ class Executor<TMutation: MutationParameters> {
         throw error;
       } else {
         const responseWithData: GraphQLResponseWithData =
-          (response: $FlowFixMe);
+          response as $FlowFixMe;
         results.push(responseWithData);
       }
     });
@@ -465,7 +496,7 @@ class Executor<TMutation: MutationParameters> {
    * response has been handled
    */
   _handleOptimisticResponses(
-    responses: $ReadOnlyArray<GraphQLResponseWithData>,
+    responses: ReadonlyArray<GraphQLResponseWithData>,
   ): boolean {
     if (responses.length > 1) {
       if (
@@ -500,6 +531,39 @@ class Executor<TMutation: MutationParameters> {
     return false;
   }
 
+  _handlePreNormalizedPayload(payload: RelayResponsePayload): void {
+    // NOTE: This path intentionally skips _maybeCompleteSubscriptionOperationTracking
+    // and the execute.next.start/end log events. Pre-normalized payloads come from
+    // the network-normalization path (NormalizationEngine via executeWithNetwork),
+    // which is used only for live exec-time-resolver queries. Those queries never
+    // complete from the consumer's perspective — exec-time resolvers re-emit on
+    // updates indefinitely — so completion tracking would never fire and is not
+    // needed.
+    if (this._state === 'completed') {
+      return;
+    }
+    this._seenActors.clear();
+    if (this._optimisticUpdates !== null) {
+      this._optimisticUpdates.forEach(update =>
+        this._getPublishQueueAndSaveActor().revertUpdate(update),
+      );
+      this._optimisticUpdates = null;
+    }
+    this._getPublishQueueAndSaveActor().commitPayload(
+      this._operation,
+      payload,
+      payload.storeUpdater ?? this._updater,
+    );
+    if (payload.isFinal) {
+      this._state = 'loading_final';
+    } else if (this._state === 'started') {
+      this._state = 'loading_incremental';
+    }
+    const updatedOwners = this._runPublishQueue(this._operation);
+    this._updateActiveState();
+    this._updateOperationTracker(updatedOwners);
+  }
+
   _handleNext(response: GraphQLResponse): void {
     if (this._state === 'completed') {
       return;
@@ -511,12 +575,38 @@ class Executor<TMutation: MutationParameters> {
 
     if (responsesWithData.length === 0) {
       // no results with data, nothing to process
-      // this can occur with extensions-only payloads
+      // this can occur with extensions-only payloads, or exec time resolver
+      // responses
       const isFinal = responses.some(x => x.extensions?.is_final === true);
       if (isFinal) {
-        this._state = 'loading_final';
-        this._updateActiveState();
-        this._incrementalPayloadsPending = false;
+        if (
+          this._useExecTimeResolvers &&
+          this._state !== 'loading_final' &&
+          responses.some(x => x.extensions?.is_normalized === true)
+        ) {
+          // An exec time resolver query can flush an empty response, if the
+          // same response has been included in other queries. Check if we need
+          // to mark the request as final
+          this._execTimeResolverResponseComplete = true;
+          if (
+            !this._isClientQuery &&
+            responses.some(x => x.extensions?.is_client_only === true)
+          ) {
+            this._isClientQuery = true;
+          }
+          // Need to update the active state to mark the query as inactive,
+          // incase server payloads have completed
+          if (this._isClientQuery) {
+            // If it is a client query, there is no server response to set the
+            // final state, so we need to set it here
+            this._state = 'loading_final';
+          }
+          this._updateActiveState();
+        } else {
+          this._state = 'loading_final';
+          this._updateActiveState();
+          this._incrementalPayloadsPending = false;
+        }
       }
       this._sink.next(response);
       return;
@@ -547,13 +637,13 @@ class Executor<TMutation: MutationParameters> {
       if (this._isSubscriptionOperation) {
         const nextID = generateUniqueClientID();
         this._operation = {
-          request: this._operation.request,
           fragment: createReaderSelector(
             this._operation.fragment.node,
             nextID,
             this._operation.fragment.variables,
             this._operation.fragment.owner,
           ),
+          request: this._operation.request,
           root: createNormalizationSelector(
             this._operation.root.node,
             nextID,
@@ -570,10 +660,13 @@ class Executor<TMutation: MutationParameters> {
       const payloadFollowups = [];
       for (let i = 0; i < normalizedResponses.length; i++) {
         const response = normalizedResponses[i];
-        const source = new RelayRecordSource(
-          response.data as $FlowExpectedError,
-        );
+        const source = new RelayRecordSource(response.data as $FlowFixMe);
         const isFinal = response.extensions?.is_final === true;
+        if (response.extensions?.is_client_only === true) {
+          // For a mixed server and client query, if the network request is
+          // skipped, need to treat it as a client query
+          this._isClientQuery = true;
+        }
         const payload: RelayResponsePayload = {
           errors: [],
           fieldPayloads: [],
@@ -592,6 +685,11 @@ class Executor<TMutation: MutationParameters> {
         if (isFinal) {
           // Need to update the active state to mark the query as inactive,
           // incase server payloads have completed
+          if (this._isClientQuery) {
+            // If it is a client query, there is no server response to set the
+            // final state, so we need to set it here
+            this._state = 'loading_final';
+          }
           this._updateActiveState();
         }
       }
@@ -657,6 +755,7 @@ class Executor<TMutation: MutationParameters> {
         ROOT_TYPE,
         {
           actorIdentifier: this._actorIdentifier,
+          deferDeduplicatedFields: false,
           getDataID: this._getDataID,
           log: this._log,
           path: [],
@@ -678,12 +777,12 @@ class Executor<TMutation: MutationParameters> {
         payload: {
           errors: null,
           fieldPayloads: null,
-          incrementalPlaceholders: null,
           followupPayloads: null,
-          source: RelayRecordSource.create(),
+          incrementalPlaceholders: null,
           isFinal: false,
+          source: RelayRecordSource.create(),
         },
-        updater: updater,
+        updater,
       });
     }
     this._optimisticUpdates = optimisticUpdates;
@@ -726,7 +825,7 @@ class Executor<TMutation: MutationParameters> {
             );
             break;
           default:
-            (followupPayload: empty);
+            followupPayload as empty;
             invariant(
               false,
               'OperationExecutor: Unexpected followup kind `%s`. when processing optimistic updates.',
@@ -775,11 +874,12 @@ class Executor<TMutation: MutationParameters> {
       followupPayload.typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: false,
         getDataID: this._getDataID,
         log: this._log,
         path: followupPayload.path,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
+        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
       this._useExecTimeResolvers,
     );
@@ -788,7 +888,7 @@ class Executor<TMutation: MutationParameters> {
   _processOptimisticModuleImport(
     normalizationRootNode: NormalizationRootNode,
     moduleImportPayload: ModuleImportPayload,
-  ): $ReadOnlyArray<OptimisticUpdate<TMutation>> {
+  ): ReadonlyArray<OptimisticUpdate<TMutation>> {
     const operation = getOperation(normalizationRootNode);
     const optimisticUpdates: Array<OptimisticUpdate<TMutation>> = [];
     const modulePayload = this._normalizeFollowupPayload(
@@ -836,8 +936,8 @@ class Executor<TMutation: MutationParameters> {
   }
 
   _processResponses(
-    responses: $ReadOnlyArray<GraphQLResponseWithData>,
-  ): $ReadOnlyArray<RelayResponsePayload> {
+    responses: ReadonlyArray<GraphQLResponseWithData>,
+  ): ReadonlyArray<RelayResponsePayload> {
     this._log({
       name: 'execute.normalize.start',
       operation: this._operation,
@@ -859,11 +959,12 @@ class Executor<TMutation: MutationParameters> {
         ROOT_TYPE,
         {
           actorIdentifier: this._actorIdentifier,
+          deferDeduplicatedFields: false,
           getDataID: this._getDataID,
           log: this._log,
           path: [],
-          treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
           shouldProcessClientComponents: this._shouldProcessClientComponents,
+          treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         },
         this._useExecTimeResolvers,
       );
@@ -885,7 +986,7 @@ class Executor<TMutation: MutationParameters> {
    * and @stream directives.
    */
   _processPayloadFollowups(
-    payloads: $ReadOnlyArray<RelayResponsePayload>,
+    payloads: ReadonlyArray<RelayResponsePayload>,
   ): void {
     if (this._state === 'completed') {
       return;
@@ -1017,6 +1118,7 @@ class Executor<TMutation: MutationParameters> {
           RelayObservable.create<empty>(sink => {
             let cancellationToken;
             const subscription = networkObservable.subscribe({
+              error: sink.error,
               next: (loadedNode: ?NormalizationRootNode) => {
                 if (loadedNode != null) {
                   const publishModuleImportPayload = () => {
@@ -1032,7 +1134,7 @@ class Executor<TMutation: MutationParameters> {
                         // OK: always have to run after an async module import resolves
                         if (shouldScheduleAsyncStoreUpdate) {
                           this._scheduleAsyncStoreUpdate(
-                            // $FlowFixMe[incompatible-call] `shouldScheduleAsyncStoreUpdate` check should cover `null` case
+                            // $FlowFixMe[incompatible-type] `shouldScheduleAsyncStoreUpdate` check should cover `null` case
                             batchAsyncModuleUpdatesFN,
                             sink.complete,
                           );
@@ -1042,10 +1144,10 @@ class Executor<TMutation: MutationParameters> {
                         }
                       });
                       this._log({
-                        name: 'execute.async.module',
+                        duration,
                         executeId: this._executeId,
+                        name: 'execute.async.module',
                         operationName: operation.name,
-                        duration,
                       });
                       if (!shouldScheduleAsyncStoreUpdate) {
                         sink.complete();
@@ -1066,7 +1168,6 @@ class Executor<TMutation: MutationParameters> {
                   sink.complete();
                 }
               },
-              error: sink.error,
             });
             return () => {
               subscription.unsubscribe();
@@ -1094,7 +1195,7 @@ class Executor<TMutation: MutationParameters> {
         );
         break;
       default:
-        (followupPayload: empty);
+        followupPayload as empty;
         invariant(
           false,
           'OperationExecutor: Unexpected followup kind `%s`.',
@@ -1171,7 +1272,7 @@ class Executor<TMutation: MutationParameters> {
     } else if (placeholder.kind === 'defer') {
       parentID = placeholder.selector.dataID;
     } else {
-      (placeholder: empty);
+      placeholder as empty;
       invariant(
         false,
         'OperationExecutor: Unsupported incremental placeholder kind `%s`.',
@@ -1224,8 +1325,8 @@ class Executor<TMutation: MutationParameters> {
       nextParentPayloads = parentPayloads;
     }
     this._source.set(parentID, {
-      record: nextParentRecord,
       fieldPayloads: nextParentPayloads,
+      record: nextParentRecord,
     });
 
     // If there were any queued responses, process them now that placeholders
@@ -1243,8 +1344,8 @@ class Executor<TMutation: MutationParameters> {
    * metadata.
    */
   _processIncrementalResponses(
-    incrementalResponses: $ReadOnlyArray<IncrementalGraphQLResponse>,
-  ): $ReadOnlyArray<RelayResponsePayload> {
+    incrementalResponses: ReadonlyArray<IncrementalGraphQLResponse>,
+  ): ReadonlyArray<RelayResponsePayload> {
     const relayPayloads = [];
     incrementalResponses.forEach(incrementalResponse => {
       const {label, path, response} = incrementalResponse;
@@ -1311,7 +1412,7 @@ class Executor<TMutation: MutationParameters> {
 
   _processDeferResponse(
     label: string,
-    path: $ReadOnlyArray<mixed>,
+    path: ReadonlyArray<unknown>,
     placeholder: DeferPlaceholder,
     response: GraphQLResponseWithData,
   ): RelayResponsePayload {
@@ -1325,11 +1426,12 @@ class Executor<TMutation: MutationParameters> {
       placeholder.typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: this._deferDeduplicatedFields,
         getDataID: this._getDataID,
         log: this._log,
         path: placeholder.path,
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
+        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
       this._useExecTimeResolvers,
     );
@@ -1352,10 +1454,10 @@ class Executor<TMutation: MutationParameters> {
       const handleFieldsRelayPayload = {
         errors: null,
         fieldPayloads,
-        incrementalPlaceholders: null,
         followupPayloads: null,
-        source: RelayRecordSource.create(),
+        incrementalPlaceholders: null,
         isFinal: response.extensions?.is_final === true,
+        source: RelayRecordSource.create(),
       };
       this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
@@ -1372,7 +1474,7 @@ class Executor<TMutation: MutationParameters> {
    */
   _processStreamResponse(
     label: string,
-    path: $ReadOnlyArray<mixed>,
+    path: ReadonlyArray<unknown>,
     placeholder: StreamPlaceholder,
     response: GraphQLResponseWithData,
   ): RelayResponsePayload {
@@ -1442,10 +1544,10 @@ class Executor<TMutation: MutationParameters> {
       const handleFieldsRelayPayload = {
         errors: null,
         fieldPayloads,
-        incrementalPlaceholders: null,
         followupPayloads: null,
-        source: RelayRecordSource.create(),
+        incrementalPlaceholders: null,
         isFinal: false,
+        source: RelayRecordSource.create(),
       };
       this._getPublishQueueAndSaveActor().commitPayload(
         this._operation,
@@ -1462,8 +1564,8 @@ class Executor<TMutation: MutationParameters> {
     parentID: DataID,
     field: NormalizationLinkedField,
     variables: Variables,
-    path: $ReadOnlyArray<mixed>,
-    normalizationPath: $ReadOnlyArray<string>,
+    path: ReadonlyArray<unknown>,
+    normalizationPath: ReadonlyArray<string>,
   ): {
     fieldPayloads: Array<HandleFieldPayload>,
     itemID: DataID,
@@ -1549,8 +1651,8 @@ class Executor<TMutation: MutationParameters> {
     nextIDs[itemIndex] = itemID;
     RelayModernRecord.setLinkedRecordIDs(nextParentRecord, storageKey, nextIDs);
     this._source.set(parentID, {
-      record: nextParentRecord,
       fieldPayloads,
+      record: nextParentRecord,
     });
     const relayPayload = this._normalizeResponse(
       response,
@@ -1558,11 +1660,12 @@ class Executor<TMutation: MutationParameters> {
       typeName,
       {
         actorIdentifier: this._actorIdentifier,
+        deferDeduplicatedFields: false,
         getDataID: this._getDataID,
         log: this._log,
         path: [...normalizationPath, responseKey, String(itemIndex)],
-        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
+        treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
       this._useExecTimeResolvers,
     );
@@ -1596,7 +1699,7 @@ class Executor<TMutation: MutationParameters> {
   }
 
   _updateOperationTracker(
-    updatedOwners: ?$ReadOnlyArray<RequestDescriptor>,
+    updatedOwners: ?ReadonlyArray<RequestDescriptor>,
   ): void {
     if (updatedOwners != null && updatedOwners.length > 0) {
       this._operationTracker.update(
@@ -1615,7 +1718,7 @@ class Executor<TMutation: MutationParameters> {
     return this._getPublishQueue(this._actorIdentifier);
   }
 
-  _getActorsToVisit(): $ReadOnlySet<ActorIdentifier> {
+  _getActorsToVisit(): ReadonlySet<ActorIdentifier> {
     if (this._seenActors.size === 0) {
       return new Set([this._actorIdentifier]);
     } else {
@@ -1625,7 +1728,7 @@ class Executor<TMutation: MutationParameters> {
 
   _runPublishQueue(
     operation?: OperationDescriptor,
-  ): $ReadOnlyArray<RequestDescriptor> {
+  ): ReadonlyArray<RequestDescriptor> {
     const updatedOwners = new Set<RequestDescriptor>();
     for (const actorIdentifier of this._getActorsToVisit()) {
       const owners = this._getPublishQueue(actorIdentifier).run(operation);
@@ -1664,11 +1767,11 @@ class Executor<TMutation: MutationParameters> {
 }
 
 function partitionGraphQLResponses(
-  responses: $ReadOnlyArray<GraphQLResponseWithData>,
+  responses: ReadonlyArray<GraphQLResponseWithData>,
 ): [
-  $ReadOnlyArray<GraphQLResponseWithData>,
-  $ReadOnlyArray<IncrementalGraphQLResponse>,
-  $ReadOnlyArray<GraphQLResponseWithData>,
+  ReadonlyArray<GraphQLResponseWithData>,
+  ReadonlyArray<IncrementalGraphQLResponse>,
+  ReadonlyArray<GraphQLResponseWithData>,
 ] {
   const nonIncrementalResponses: Array<GraphQLResponseWithData> = [];
   const incrementalResponses: Array<IncrementalGraphQLResponse> = [];
@@ -1699,7 +1802,7 @@ function partitionGraphQLResponses(
   return [nonIncrementalResponses, incrementalResponses, normalizedResponses];
 }
 
-function stableStringify(value: mixed): string {
+function stableStringify(value: unknown): string {
   return JSON.stringify(stableCopy(value)) ?? ''; // null-check for flow
 }
 

package/store/RelayConcreteVariables.js.flow

@@ -71,7 +71,7 @@ function getFragmentVariables(
         variables[definition.name] = rootVariables[definition.name];
         break;
       default:
-        (definition: empty);
+        definition as empty;
         invariant(
           false,
           'RelayConcreteVariables: Unexpected node kind `%s` in fragment `%s`.',
@@ -96,7 +96,7 @@ function getOperationVariables(
   providedVariables: ?ProvidedVariablesType,
   variables: Variables,
 ): Variables {
-  const operationVariables: {[string]: mixed} = {};
+  const operationVariables: {[string]: unknown} = {};
   operation.argumentDefinitions.forEach(def => {
     let value = def.defaultValue;
     if (variables[def.name] != null) {
@@ -115,8 +115,8 @@ function getOperationVariables(
 
 function getLocalVariables(
   currentVariables: Variables,
-  argumentDefinitions: ?$ReadOnlyArray<NormalizationLocalArgumentDefinition>,
-  args: ?$ReadOnlyArray<NormalizationArgument>,
+  argumentDefinitions: ?ReadonlyArray<NormalizationLocalArgumentDefinition>,
+  args: ?ReadonlyArray<NormalizationArgument>,
 ): Variables {
   if (argumentDefinitions == null) {
     return currentVariables;
@@ -132,7 +132,7 @@ function getLocalVariables(
 }
 
 module.exports = {
-  getLocalVariables,
   getFragmentVariables,
+  getLocalVariables,
   getOperationVariables,
 };