relay-runtime 20.1.1 → 21.0.1

package/multi-actor-environment/MultiActorEnvironment.js.flow

@@ -55,7 +55,7 @@ const RelayModernStore = require('../store/RelayModernStore');
 const RelayRecordSource = require('../store/RelayRecordSource');
 const ActorSpecificEnvironment = require('./ActorSpecificEnvironment');
 
-export type MultiActorEnvironmentConfig = $ReadOnly<{
+export type MultiActorEnvironmentConfig = Readonly<{
   createConfigNameForActor?: ?(actorIdentifier: ActorIdentifier) => string,
   createNetworkForActor: (actorIdentifier: ActorIdentifier) => INetwork,
   createStoreForActor?: ?(actorIdentifier: ActorIdentifier) => Store,
@@ -64,33 +64,39 @@ export type MultiActorEnvironmentConfig = $ReadOnly<{
   handlerProvider?: HandlerProvider,
   isServer?: ?boolean,
   logFn?: ?LogFunction,
-  missingFieldHandlers?: ?$ReadOnlyArray<MissingFieldHandler>,
+  missingFieldHandlers?: ?ReadonlyArray<MissingFieldHandler>,
   normalizeResponse?: NormalizeResponseFunction,
   operationLoader?: ?OperationLoader,
   relayFieldLogger?: ?RelayFieldLogger,
   scheduler?: ?TaskScheduler,
   shouldProcessClientComponents?: ?boolean,
   treatMissingFieldsAsNull?: boolean,
+  deferDeduplicatedFields?: boolean,
 }>;
 
 class MultiActorEnvironment implements IMultiActorEnvironment {
-  +_actorEnvironments: Map<ActorIdentifier, IActorEnvironment>;
-  +_createConfigNameForActor: ?(actorIdentifier: ActorIdentifier) => string;
-  +_createNetworkForActor: (actorIdentifier: ActorIdentifier) => INetwork;
-  +_createStoreForActor: ?(actorIdentifier: ActorIdentifier) => Store;
-  +_defaultRenderPolicy: RenderPolicy;
-  +_getDataID: GetDataID;
-  +_handlerProvider: HandlerProvider;
-  +_isServer: boolean;
-  +_logFn: LogFunction;
-  +_missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>;
-  +_normalizeResponse: NormalizeResponseFunction;
-  +_operationExecutions: Map<string, ActiveState>;
-  +_operationLoader: ?OperationLoader;
-  +_relayFieldLogger: RelayFieldLogger;
-  +_scheduler: ?TaskScheduler;
-  +_shouldProcessClientComponents: ?boolean;
-  +_treatMissingFieldsAsNull: boolean;
+  readonly _actorEnvironments: Map<ActorIdentifier, IActorEnvironment>;
+  readonly _createConfigNameForActor: ?(
+    actorIdentifier: ActorIdentifier,
+  ) => string;
+  readonly _createNetworkForActor: (
+    actorIdentifier: ActorIdentifier,
+  ) => INetwork;
+  readonly _createStoreForActor: ?(actorIdentifier: ActorIdentifier) => Store;
+  readonly _defaultRenderPolicy: RenderPolicy;
+  readonly _getDataID: GetDataID;
+  readonly _handlerProvider: HandlerProvider;
+  readonly _isServer: boolean;
+  readonly _logFn: LogFunction;
+  readonly _missingFieldHandlers: ReadonlyArray<MissingFieldHandler>;
+  readonly _normalizeResponse: NormalizeResponseFunction;
+  readonly _operationExecutions: Map<string, ActiveState>;
+  readonly _operationLoader: ?OperationLoader;
+  readonly _relayFieldLogger: RelayFieldLogger;
+  readonly _scheduler: ?TaskScheduler;
+  readonly _shouldProcessClientComponents: ?boolean;
+  readonly _treatMissingFieldsAsNull: boolean;
+  readonly _deferDeduplicatedFields: boolean;
 
   constructor(config: MultiActorEnvironmentConfig) {
     this._actorEnvironments = new Map();
@@ -106,6 +112,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     this._relayFieldLogger = config.relayFieldLogger ?? defaultRelayFieldLogger;
     this._shouldProcessClientComponents = config.shouldProcessClientComponents;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull ?? false;
+    this._deferDeduplicatedFields = config.deferDeduplicatedFields ?? false;
     this._isServer = config.isServer ?? false;
     this._missingFieldHandlers = config.missingFieldHandlers ?? [];
     this._createStoreForActor = config.createStoreForActor;
@@ -175,7 +182,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
   _checkSelectorAndHandleMissingFields(
     actorEnvironment: IActorEnvironment,
     operation: OperationDescriptor,
-    handlers: $ReadOnlyArray<MissingFieldHandler>,
+    handlers: ReadonlyArray<MissingFieldHandler>,
   ): OperationAvailability {
     const targets: Map<ActorIdentifier, MutableRecordSource> = new Map([
       [actorEnvironment.actorIdentifier, RelayRecordSource.create()],
@@ -267,7 +274,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     });
   }
 
-  applyMutation<TMutation: MutationParameters>(
+  applyMutation<TMutation extends MutationParameters>(
     actorEnvironment: IActorEnvironment,
     optimisticConfig: OptimisticResponseConfig<TMutation>,
   ): Disposable {
@@ -341,7 +348,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     });
   }
 
-  executeSubscription<TMutation: MutationParameters>(
+  executeSubscription<TMutation extends MutationParameters>(
     actorEnvironment: IActorEnvironment,
     {
       operation,
@@ -368,7 +375,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     });
   }
 
-  executeMutation<TMutation: MutationParameters>(
+  executeMutation<TMutation extends MutationParameters>(
     actorEnvironment: IActorEnvironment,
     {
       operation,
@@ -432,7 +439,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
     return this._isServer;
   }
 
-  _execute<TMutation: MutationParameters>(
+  _execute<TMutation extends MutationParameters>(
     actorEnvironment: IActorEnvironment,
     {
       createSource,
@@ -471,6 +478,7 @@ class MultiActorEnvironment implements IMultiActorEnvironment {
           return this.forActor(actorIdentifier).getStore();
         },
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        deferDeduplicatedFields: this._deferDeduplicatedFields,
         updater,
         log: this._logFn,
         normalizeResponse: this._normalizeResponse,

package/multi-actor-environment/MultiActorEnvironmentTypes.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { MutationParameters } from '../mutations/commitMutation';
+import {GraphQLResponse, PayloadData} from '../network/RelayNetworkTypes';
+import { RelayObservable } from '../network/RelayObservable';
+import {
+  Environment as IEnvironment,
+  ExecuteMutationConfig,
+  OperationAvailability,
+  OperationDescriptor,
+  OptimisticResponseConfig,
+  OptimisticUpdateFunction,
+  RecordSourceProxy,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  Snapshot,
+  StoreUpdater,
+} from '../store/RelayStoreTypes';
+import { Disposable } from '../util/RelayRuntimeTypes';
+import { ActorIdentifier } from './ActorIdentifier';
+
+export type MultiActorStoreUpdater = (
+    actorIdentifier: ActorIdentifier,
+    environment: ActorEnvironment,
+    store: RecordSourceProxy,
+) => void;
+
+export interface ActorEnvironment extends IEnvironment {
+    /**
+     * Reference to the main MultActorEnvironment that handles
+     * the network execution/and responsible for network integration
+     */
+    readonly multActorEnvironment: MultiActorEnvironment;
+
+    /**
+     * Identifier of the actor for the current active environment
+     */
+    readonly actorIdentifier: ActorIdentifier;
+
+    /**
+     * Optional. A human-readable identifier of the environment.
+     * This value should be visible in the dev tools.
+     */
+    readonly configName: string | null;
+}
+
+/**
+ * Interface for the main (or parent) multi-actor environment that contains
+ * the map of individual actor-specific sub-environments. These sub-environments
+ * implement the Relay IEnvironment interface.
+ */
+export interface MultiActorEnvironment {
+    /**
+     * A factory of actor-specific environments.
+     */
+    forActor(actorIdentifier: ActorIdentifier): ActorEnvironment;
+
+    /**
+     * Determine if the operation can be resolved with data in the store (i.e. no
+     * fields are missing).
+     *
+     * Note that this operation effectively "executes" the selector against the
+     * cache and therefore takes time proportional to the size/complexity of the
+     * selector.
+     */
+    check(actorEnvironment: ActorEnvironment, operation: OperationDescriptor): OperationAvailability;
+
+    /**
+     * Subscribe to changes to the results of a selector. The callback is called
+     * when data has been committed to the store that would cause the results of
+     * the snapshot's selector to change.
+     */
+    subscribe(
+        actorEnvironment: ActorEnvironment,
+        snapshot: Snapshot,
+        callback: (snapshot: Snapshot) => void,
+    ): Disposable;
+
+    /**
+     * Ensure that all the records necessary to fulfill the given selector are
+     * retained in-memory. The records will not be eligible for garbage collection
+     * until the returned reference is disposed.
+     */
+    retain(actorEnvironment: ActorEnvironment, operation: OperationDescriptor): Disposable;
+
+    /**
+     * Apply an optimistic update to the environment. The mutation can be reverted
+     * by calling `dispose()` on the returned value.
+     */
+    applyUpdate(actorEnvironment: ActorEnvironment, optimisticUpdate: OptimisticUpdateFunction): Disposable;
+
+    /**
+     * Revert updates for the `update` function.
+     */
+    revertUpdate(actorEnvironment: ActorEnvironment, update: OptimisticUpdateFunction): void;
+
+    /**
+     * Revert updates for the `update` function, and apply the `replacement` update.
+     */
+    replaceUpdate(
+        actorEnvironment: ActorEnvironment,
+        update: OptimisticUpdateFunction,
+        replacement: OptimisticUpdateFunction,
+    ): void;
+
+    /**
+     * Apply an optimistic mutation response and/or updater. The mutation can be
+     * reverted by calling `dispose()` on the returned value.
+     */
+    applyMutation(
+        actorEnvironment: ActorEnvironment,
+        optimisticConfig: OptimisticResponseConfig<MutationParameters>,
+    ): Disposable;
+
+    /**
+     * Commit an updater to the environment. This mutation cannot be reverted and
+     * should therefore not be used for optimistic updates. This is mainly
+     * intended for updating fields from client schema extensions.
+     */
+    commitUpdate(actorEnvironment: ActorEnvironment, updater: StoreUpdater): void;
+
+    /**
+     * Commit store updates for each actor-specific environment known to MultActorEnvironment
+     */
+    commitMultiActorUpdate(updater: MultiActorStoreUpdater): void;
+
+    /**
+     * Commit a payload to the environment using the given operation selector.
+     */
+    commitPayload(
+        actorEnvironment: ActorEnvironment,
+        operationDescriptor: OperationDescriptor,
+        payload: PayloadData,
+    ): void;
+
+    /**
+     * Read the results of a selector from in-memory records in the store.
+     */
+    lookup(actorEnvironment: ActorEnvironment, selector: SingularReaderSelector): Snapshot;
+
+    /**
+     * Send a query to the server with Observer semantics: one or more
+     * responses may be returned (via `next`) over time followed by either
+     * the request completing (`completed`) or an error (`error`).
+     *
+     * Note: Observables are lazy, so calling this method will do nothing until
+     * the result is subscribed to: environment.execute({...}).subscribe({...}).
+     */
+    execute(
+        actorEnvironment: ActorEnvironment,
+        config: {
+            operation: OperationDescriptor;
+        },
+    ): RelayObservable<GraphQLResponse>;
+
+    /**
+     * Send a subscription to the server with Observer semantics: one or more
+     * responses may be returned (via `next`) over time followed by either
+     * the request completing (`completed`) or an error (`error`).
+     *
+     * Networks/servers that support subscriptions may choose to hold the
+     * subscription open indefinitely such that `complete` is not called.
+     *
+     * Note: Observables are lazy, so calling this method will do nothing until
+     * the result is subscribed to: environment.executeSubscription({...}).subscribe({...}).
+     */
+    executeSubscription(
+        actorEnvironment: ActorEnvironment,
+        config: {
+            operation: OperationDescriptor;
+            updater?: SelectorStoreUpdater<MutationParameters['response']> | null;
+        },
+    ): RelayObservable<GraphQLResponse>;
+
+    /**
+     * Returns an Observable of GraphQLResponse resulting from executing the
+     * provided Mutation operation, the result of which is then normalized and
+     * committed to the publish queue along with an optional optimistic response
+     * or updater.
+     *
+     * Note: Observables are lazy, so calling this method will do nothing until
+     * the result is subscribed to:
+     * environment.executeMutation({...}).subscribe({...}).
+     */
+    executeMutation(
+        actorEnvironment: ActorEnvironment,
+        config: ExecuteMutationConfig<MutationParameters>,
+    ): RelayObservable<GraphQLResponse>;
+
+    /**
+     * Returns an Observable of GraphQLResponse resulting from executing the
+     * provided Query or Subscription operation responses, the result of which is
+     * then normalized and committed to the publish queue.
+     *
+     * Note: Observables are lazy, so calling this method will do nothing until
+     * the result is subscribed to:
+     * environment.executeWithSource({...}).subscribe({...}).
+     */
+    executeWithSource(
+        actorEnvironment: ActorEnvironment,
+        arg: {
+            operation: OperationDescriptor;
+            source: RelayObservable<GraphQLResponse>;
+        },
+    ): RelayObservable<GraphQLResponse>;
+
+    /**
+     * Returns true if a request is currently "active", meaning it's currently
+     * actively receiving payloads or downloading modules, and has not received
+     * a final payload yet. Note that a request might still be pending (or "in flight")
+     * without actively receiving payload, for example a live query or an
+     * active GraphQL subscription
+     */
+    isRequestActive(actorEnvironment: ActorEnvironment, requestIdentifier: string): boolean;
+
+    /**
+     * Returns `true` if execute in the server environment
+     */
+    isServer(): boolean;
+}

package/multi-actor-environment/MultiActorEnvironmentTypes.js.flow

@@ -46,12 +46,12 @@ export interface IActorEnvironment extends IEnvironment {
    * Reference to the main MultiActorEnvironment that handles
    * the network execution/and responsible for network integration
    */
-  +multiActorEnvironment: IMultiActorEnvironment;
+  readonly multiActorEnvironment: IMultiActorEnvironment;
 
   /**
    * Identifier of the actor for the current active environment
    */
-  +actorIdentifier: ActorIdentifier;
+  readonly actorIdentifier: ActorIdentifier;
 
   /**
    * TODO: this needs to move the the MultiActorEnvironment with different API.
@@ -62,7 +62,7 @@ export interface IActorEnvironment extends IEnvironment {
    * Optional. A human-readable identifier of the environment.
    * This value should be visible in the dev tools.
    */
-  +configName: ?string;
+  readonly configName: ?string;
 }
 
 /**
@@ -140,7 +140,7 @@ export interface IMultiActorEnvironment {
    * Apply an optimistic mutation response and/or updater. The mutation can be
    * reverted by calling `dispose()` on the returned value.
    */
-  applyMutation<TMutation: MutationParameters>(
+  applyMutation<TMutation extends MutationParameters>(
     actorEnvironment: IActorEnvironment,
     optimisticConfig: OptimisticResponseConfig<TMutation>,
   ): Disposable;
@@ -203,7 +203,7 @@ export interface IMultiActorEnvironment {
    * Note: Observables are lazy, so calling this method will do nothing until
    * the result is subscribed to: environment.executeSubscription({...}).subscribe({...}).
    */
-  executeSubscription<TMutation: MutationParameters>(
+  executeSubscription<TMutation extends MutationParameters>(
     actorEnvironment: IActorEnvironment,
     config: {
       operation: OperationDescriptor,
@@ -221,7 +221,7 @@ export interface IMultiActorEnvironment {
    * the result is subscribed to:
    * environment.executeMutation({...}).subscribe({...}).
    */
-  executeMutation<TMutation: MutationParameters>(
+  executeMutation<TMutation extends MutationParameters>(
     actorEnvironment: IActorEnvironment,
     config: ExecuteMutationConfig<TMutation>,
   ): RelayObservable<GraphQLResponse>;

package/multi-actor-environment/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export { ActorIdentifier, getActorIdentifier } from './ActorIdentifier';
+
+export { MultiActorEnvironment } from './MultiActorEnvironment';
+export {
+    ActorEnvironment as IActorEnvironment,
+    MultiActorEnvironment as IMultiActorEnvironment,
+} from './MultiActorEnvironmentTypes';

package/multi-actor-environment.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export * from './multi-actor-environment';

package/mutations/RelayDeclarativeMutationConfig.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { SelectorStoreUpdater } from '../store/RelayStoreTypes';
+import { ConcreteRequest } from '../util/RelayConcreteNode';
+import { Variables } from '../util/RelayRuntimeTypes';
+
+export type MutationTypes = 'RANGE_ADD' | 'RANGE_DELETE' | 'NODE_DELETE';
+
+export type RangeOperations = 'append' | 'prepend';
+export type RangeBehaviorsFunction = (connectionArgs: { [name: string]: unknown }) => RangeOperations;
+export interface RangeBehaviorsObject {
+    [key: string]: RangeOperations;
+}
+export type RangeBehaviors = RangeBehaviorsFunction | RangeBehaviorsObject;
+
+export interface RangeAddConfig {
+    type: 'RANGE_ADD';
+    parentName?: string | undefined;
+    parentID?: string | undefined;
+    connectionInfo?:
+        | ReadonlyArray<{
+            key: string;
+            filters?: Variables | undefined;
+            rangeBehavior: string;
+        }>
+        | undefined;
+    connectionName?: string | undefined;
+    edgeName: string;
+    rangeBehaviors?: RangeBehaviors | undefined;
+}
+
+export interface RangeDeleteConfig {
+    type: 'RANGE_DELETE';
+    parentName?: string | undefined;
+    parentID?: string | undefined;
+    connectionKeys?:
+        | ReadonlyArray<{
+            key: string;
+            filters?: Variables | undefined;
+        }>
+        | undefined;
+    connectionName?: string | undefined;
+    deletedIDFieldName: string | readonly string[];
+    pathToConnection: readonly string[];
+}
+
+export interface NodeDeleteConfig {
+    type: 'NODE_DELETE';
+    parentName?: string | undefined;
+    parentID?: string | undefined;
+    connectionName?: string | undefined;
+    deletedIDFieldName: string;
+}
+
+export type DeclarativeMutationConfig = RangeAddConfig | RangeDeleteConfig | NodeDeleteConfig;
+
+export function convert(
+    configs: DeclarativeMutationConfig[],
+    request: ConcreteRequest,
+    optimisticUpdater?: SelectorStoreUpdater,
+    updater?: SelectorStoreUpdater,
+): {
+    optimisticUpdater: SelectorStoreUpdater;
+    updater: SelectorStoreUpdater;
+};

package/mutations/RelayDeclarativeMutationConfig.js.flow

@@ -27,13 +27,13 @@ const MutationTypes = Object.freeze({
   RANGE_DELETE: 'RANGE_DELETE',
   NODE_DELETE: 'NODE_DELETE',
 });
-export type MutationType = $Values<typeof MutationTypes>;
+export type MutationType = Values<typeof MutationTypes>;
 
 const RangeOperations = Object.freeze({
   APPEND: 'append',
   PREPEND: 'prepend',
 });
-export type RangeOperation = $Values<typeof RangeOperations>;
+export type RangeOperation = Values<typeof RangeOperations>;
 
 type RangeBehaviorsFunction = (connectionArgs: {
   [name: string]: $FlowFixMe,
@@ -82,7 +82,7 @@ export type DeclarativeMutationConfig =
   | RangeDeleteConfig
   | NodeDeleteConfig;
 
-function convert<TMutation: MutationParameters>(
+function convert<TMutation extends MutationParameters>(
   configs: Array<DeclarativeMutationConfig>,
   request: ConcreteRequest,
   optimisticUpdater?: ?SelectorStoreUpdater<TMutation['response']>,
@@ -145,13 +145,13 @@ function convert<TMutation: MutationParameters>(
 function nodeDelete(
   config: NodeDeleteConfig,
   request: ConcreteRequest,
-): ?SelectorStoreUpdater<mixed> {
+): ?SelectorStoreUpdater<unknown> {
   const {deletedIDFieldName} = config;
   const rootField = getRootField(request);
   if (!rootField) {
     return null;
   }
-  return (store: RecordSourceSelectorProxy, data: ?mixed) => {
+  return (store: RecordSourceSelectorProxy, data: ?unknown) => {
     const payload = store.getRootField(rootField);
     if (!payload) {
       return;
@@ -169,7 +169,7 @@ function nodeDelete(
 function rangeAdd(
   config: RangeAddConfig,
   request: ConcreteRequest,
-): ?SelectorStoreUpdater<mixed> {
+): ?SelectorStoreUpdater<unknown> {
   const {parentID, connectionInfo, edgeName} = config;
   if (!parentID) {
     warning(
@@ -183,7 +183,7 @@ function rangeAdd(
   if (!connectionInfo || !rootField) {
     return null;
   }
-  return (store: RecordSourceSelectorProxy, data: ?mixed) => {
+  return (store: RecordSourceSelectorProxy, data: ?unknown) => {
     const parent = store.get(parentID);
     if (!parent) {
       return;
@@ -237,7 +237,7 @@ function rangeAdd(
 function rangeDelete(
   config: RangeDeleteConfig,
   request: ConcreteRequest,
-): ?SelectorStoreUpdater<mixed> {
+): ?SelectorStoreUpdater<unknown> {
   const {parentID, connectionKeys, pathToConnection, deletedIDFieldName} =
     config;
   if (!parentID) {
@@ -252,7 +252,7 @@ function rangeDelete(
   if (!rootField) {
     return null;
   }
-  return (store: RecordSourceSelectorProxy, data: ?mixed) => {
+  return (store: RecordSourceSelectorProxy, data: ?unknown) => {
     if (!data) {
       return;
     }

package/mutations/RelayRecordProxy.js.flow

@@ -61,16 +61,16 @@ class RelayRecordProxy implements RecordProxy {
     return type;
   }
 
-  getValue(name: string, args?: ?Arguments): mixed {
+  getValue(name: string, args?: ?Arguments): unknown {
     const storageKey = getStableStorageKey(name, args);
     return this._mutator.getValue(this._dataID, storageKey);
   }
 
   setValue(
-    value: mixed,
+    value: unknown,
     name: string,
     args?: ?Arguments,
-    errors?: ?$ReadOnlyArray<TRelayFieldError>,
+    errors?: ?ReadonlyArray<TRelayFieldError>,
   ): RecordProxy {
     invariant(
       isValidLeafValue(value),
@@ -82,10 +82,7 @@ class RelayRecordProxy implements RecordProxy {
     return this.setValue__UNSAFE(value, name, args, errors);
   }
 
-  getErrors(
-    name: string,
-    args?: ?Arguments,
-  ): ?$ReadOnlyArray<TRelayFieldError> {
+  getErrors(name: string, args?: ?Arguments): ?ReadonlyArray<TRelayFieldError> {
     const storageKey = getStableStorageKey(name, args);
     return this._mutator.getErrors(this._dataID, storageKey);
   }
@@ -94,10 +91,10 @@ class RelayRecordProxy implements RecordProxy {
   // We already validated that the value has the correct type
   // so it should be safe to store complex structures as scalar values (custom scalars)
   setValue__UNSAFE(
-    value: mixed,
+    value: unknown,
     name: string,
     args?: ?Arguments,
-    errors?: ?$ReadOnlyArray<TRelayFieldError>,
+    errors?: ?ReadonlyArray<TRelayFieldError>,
   ): RecordProxy {
     const storageKey = getStableStorageKey(name, args);
     this._mutator.setValue(this._dataID, storageKey, value);
@@ -166,7 +163,7 @@ class RelayRecordProxy implements RecordProxy {
   }
 
   setLinkedRecords(
-    records: $ReadOnlyArray<?RecordProxy>,
+    records: ReadonlyArray<?RecordProxy>,
     name: string,
     args?: ?Arguments,
   ): RecordProxy {
@@ -186,7 +183,7 @@ class RelayRecordProxy implements RecordProxy {
   }
 }
 
-function isValidLeafValue(value: mixed): boolean {
+function isValidLeafValue(value: unknown): boolean {
   return (
     value == null ||
     typeof value !== 'object' ||

package/mutations/RelayRecordSourceMutator.js.flow

@@ -161,7 +161,7 @@ class RelayRecordSourceMutator {
     }
   }
 
-  getValue(dataID: DataID, storageKey: string): mixed {
+  getValue(dataID: DataID, storageKey: string): unknown {
     for (let ii = 0; ii < this.__sources.length; ii++) {
       const record = this.__sources[ii].get(dataID);
       if (record) {
@@ -175,7 +175,7 @@ class RelayRecordSourceMutator {
     }
   }
 
-  setValue(dataID: DataID, storageKey: string, value: mixed): void {
+  setValue(dataID: DataID, storageKey: string, value: unknown): void {
     const sinkRecord = this._getSinkRecord(dataID);
     RelayModernRecord.setValue(sinkRecord, storageKey, value);
   }
@@ -183,7 +183,7 @@ class RelayRecordSourceMutator {
   getErrors(
     dataID: DataID,
     storageKey: string,
-  ): ?$ReadOnlyArray<TRelayFieldError> {
+  ): ?ReadonlyArray<TRelayFieldError> {
     for (let ii = 0; ii < this.__sources.length; ii++) {
       const record = this.__sources[ii].get(dataID);
       if (record) {
@@ -200,7 +200,7 @@ class RelayRecordSourceMutator {
   setErrors(
     dataID: DataID,
     storageKey: string,
-    errors?: $ReadOnlyArray<TRelayFieldError>,
+    errors?: ReadonlyArray<TRelayFieldError>,
   ): void {
     const sinkRecord = this._getSinkRecord(dataID);
     RelayModernRecord.setErrors(sinkRecord, storageKey, errors);