relay-runtime 20.1.1 → 21.0.1

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,
 };

package/store/RelayErrorTrie.js.flow

@@ -18,13 +18,13 @@ const SELF: Self = Symbol('$SELF');
 
 export opaque type Self = typeof SELF;
 
-export type TRelayFieldErrorForDisplay = $ReadOnly<{
-  path?: $ReadOnlyArray<string | number>,
+export type TRelayFieldErrorForDisplay = Readonly<{
+  path?: ReadonlyArray<string | number>,
   severity?: 'CRITICAL' | 'ERROR' | 'WARNING',
 }>;
 
 // We display a subset of the TRelayFieldError to the user. Removing the message by default.
-export type TRelayFieldError = $ReadOnly<{
+export type TRelayFieldError = Readonly<{
   ...TRelayFieldErrorForDisplay,
   message: string,
 }>;
@@ -49,13 +49,13 @@ export opaque type RelayErrorTrie = Map<
 >;
 
 function buildErrorTrie(
-  errors: ?$ReadOnlyArray<PayloadError>,
+  errors: ?ReadonlyArray<PayloadError>,
 ): RelayErrorTrie | null {
   if (errors == null) {
     return null;
   }
 
-  const trie: $NonMaybeType<RelayErrorTrie> = new Map();
+  const trie: NonNullable<RelayErrorTrie> = new Map();
   // eslint-disable-next-line no-unused-vars
   ERRORS: for (const {path, locations: _, ...error} of errors) {
     if (path == null) {
@@ -100,7 +100,7 @@ function buildErrorTrie(
 function getErrorsByKey(
   trie: RelayErrorTrie,
   key: string | number,
-): $ReadOnlyArray<TRelayFieldError> | null {
+): ReadonlyArray<TRelayFieldError> | null {
   const value = trie.get(key);
   if (value == null) {
     return null;
@@ -109,7 +109,7 @@ function getErrorsByKey(
     return value;
   }
   const errors: Array<
-    $ReadOnly<{
+    Readonly<{
       message: string,
       path?: Array<string | number>,
       severity?: 'CRITICAL' | 'ERROR' | 'WARNING',
@@ -122,7 +122,7 @@ function getErrorsByKey(
 function recursivelyCopyErrorsIntoArray(
   trieOrSet: RelayErrorTrie,
   errors: Array<
-    $ReadOnly<{
+    Readonly<{
       message: string,
       path?: Array<string | number>,
       severity?: 'CRITICAL' | 'ERROR' | 'WARNING',
@@ -165,14 +165,14 @@ function getNestedErrorTrieByKey(
   return null;
 }
 
-module.exports = ({
+module.exports = {
   SELF,
   buildErrorTrie,
-  getNestedErrorTrieByKey,
   getErrorsByKey,
-}: {
+  getNestedErrorTrieByKey,
+} as {
   SELF: typeof SELF,
   buildErrorTrie: typeof buildErrorTrie,
   getNestedErrorTrieByKey: typeof getNestedErrorTrieByKey,
   getErrorsByKey: typeof getErrorsByKey,
-});
+};

package/store/RelayExperimentalGraphResponseHandler.js.flow

@@ -58,7 +58,7 @@ class GraphModeHandler {
           this._streamIdToCacheKey.clear();
           break;
         default:
-          (chunk.$kind: empty);
+          chunk.$kind as empty;
       }
     }
     return this._recordSource;
@@ -93,12 +93,12 @@ class GraphModeHandler {
           } else {
             if (value.hasOwnProperty('__id')) {
               // Singular
-              const streamID: number = (value.__id: any);
+              const streamID: number = value.__id as any;
               const id = this._lookupCacheKey(streamID);
               RelayModernRecord.setLinkedRecordID(parentRecord, key, id);
             } else if (value.hasOwnProperty('__ids')) {
               // Plural
-              const streamIDs: Array<number | null> = (value.__ids: any);
+              const streamIDs: Array<number | null> = value.__ids as any;
               const ids = streamIDs.map((sID): ?DataID => {
                 return sID == null ? null : this._lookupCacheKey(sID);
               });

package/store/RelayExperimentalGraphResponseTransform.js.flow

@@ -183,7 +183,7 @@ export class GraphModeNormalizer {
   }
 
   _getObjectType(data: PayloadData): string {
-    const typeName = (data: any)[TYPENAME_KEY];
+    const typeName = (data as any)[TYPENAME_KEY];
     invariant(
       typeName != null,
       'Expected a typename for record `%s`.',
@@ -198,7 +198,7 @@ export class GraphModeNormalizer {
     return getStorageKey(selection, this._variables);
   }
 
-  _getVariableValue(name: string): mixed {
+  _getVariableValue(name: string): unknown {
     invariant(
       this._variables.hasOwnProperty(name),
       'Unexpected undefined variable `%s`.',
@@ -218,10 +218,10 @@ export class GraphModeNormalizer {
     const $streamID = this._getStreamID();
     yield {
       ...rootFields,
-      $kind: 'Record',
-      $streamID,
       __id: dataID,
       __typename: ROOT_TYPE,
+      $kind: 'Record',
+      $streamID,
     } as RecordChunk;
     yield {
       $kind: 'Complete',
@@ -243,9 +243,9 @@ export class GraphModeNormalizer {
       // experimental transform
       yield {
         ...fields,
-        $kind: 'Record',
-        __typename: typename,
         __id: cacheKey,
+        __typename: typename,
+        $kind: 'Record',
         $streamID,
       } as RecordChunk;
     } else if (Object.keys(fields).length > 0) {
@@ -267,7 +267,7 @@ export class GraphModeNormalizer {
       switch (selection.kind) {
         case LINKED_FIELD: {
           const responseKey = selection.alias ?? selection.name;
-          const fieldData: PayloadData = (data[responseKey]: any);
+          const fieldData: PayloadData = data[responseKey] as any;
 
           const storageKey = this._getStorageKey(selection);
 
@@ -305,7 +305,7 @@ export class GraphModeNormalizer {
             this.duplicateFieldsAvoided++;
             break;
           }
-          const fieldData: ChunkField = (data[responseKey]: any);
+          const fieldData: ChunkField = data[responseKey] as any;
 
           parentFields[storageKey] = fieldData;
           sentFields.add(storageKey);
@@ -378,8 +378,9 @@ export class GraphModeNormalizer {
             // Otherwise data *for this selection* should not be present: enqueue
             // metadata to process the subsequent response chunk.
             this._incrementalPlaceholders.push({
-              kind: 'defer',
+              actorIdentifier: this._actorIdentifier,
               data,
+              kind: 'defer',
               label: selection.label,
               path: [...this._path],
               selector: createNormalizationSelector(
@@ -388,7 +389,6 @@ export class GraphModeNormalizer {
                 this._variables,
               ),
               typeName: this._getObjectType(data),
-              actorIdentifier: this._actorIdentifier,
             });
           }
           break;

package/store/RelayModernEnvironment.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 type { GetDataID } from './RelayResponseNormalizer';
+
+import { HandlerProvider } from '../handlers/RelayDefaultHandlerProvider';
+import {GraphQLResponse, Network, PayloadData, UploadableMap} from '../network/RelayNetworkTypes';
+import { RelayObservable } from '../network/RelayObservable';
+import {Disposable, RenderPolicy} from '../util/RelayRuntimeTypes';
+import { TaskScheduler } from './OperationExecutor';
+import { RelayOperationTracker } from './RelayOperationTracker';
+import {
+  Environment,
+  LogFunction,
+  MissingFieldHandler,
+  OperationAvailability,
+  OperationDescriptor,
+  OperationLoader,
+  OperationTracker,
+  OptimisticResponseConfig,
+  OptimisticUpdateFunction,
+  RelayFieldLogger,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  Snapshot,
+  Store,
+  StoreUpdater,
+} from './RelayStoreTypes';
+
+export interface EnvironmentConfig {
+    readonly configName?: string | undefined;
+    readonly handlerProvider?: HandlerProvider | null | undefined;
+    readonly treatMissingFieldsAsNull?: boolean | undefined;
+    readonly log?: LogFunction | null | undefined;
+    readonly operationLoader?: OperationLoader | null | undefined;
+    readonly network: Network;
+    readonly scheduler?: TaskScheduler | null | undefined;
+    readonly store?: Store;
+    readonly missingFieldHandlers?: readonly MissingFieldHandler[] | null | undefined;
+    readonly operationTracker?: OperationTracker | null | undefined;
+    readonly getDataID?: GetDataID | null | undefined;
+    readonly UNSTABLE_defaultRenderPolicy?: RenderPolicy | null | undefined;
+    readonly options?: unknown | undefined;
+    readonly isServer?: boolean | undefined;
+    readonly relayFieldLogger?: RelayFieldLogger | null | undefined;
+    readonly shouldProcessClientComponents?: boolean | null | undefined;
+}
+
+export default class RelayModernEnvironment implements Environment {
+    options: unknown;
+    configName: string | null | undefined;
+    relayFieldLogger: RelayFieldLogger;
+    constructor(config: EnvironmentConfig);
+    getStore(): Store;
+    getNetwork(): Network;
+    getOperationTracker(): RelayOperationTracker;
+    isRequestActive(requestIdentifier: string): boolean;
+    applyUpdate(optimisticUpdate: OptimisticUpdateFunction): Disposable;
+    revertUpdate(update: OptimisticUpdateFunction): void;
+    replaceUpdate(update: OptimisticUpdateFunction, newUpdate: OptimisticUpdateFunction): void;
+    applyMutation(optimisticConfig: OptimisticResponseConfig): Disposable;
+    check(operation: OperationDescriptor): OperationAvailability;
+    commitPayload(operationDescriptor: OperationDescriptor, payload: PayloadData): void;
+    commitUpdate(updater: StoreUpdater): void;
+    lookup(readSelector: SingularReaderSelector): Snapshot;
+    subscribe(snapshot: Snapshot, callback: (snapshot: Snapshot) => void): Disposable;
+    retain(operation: OperationDescriptor): Disposable;
+    isServer(): boolean;
+    execute(data: {
+        operation: OperationDescriptor;
+        updater?: SelectorStoreUpdater | null | undefined;
+    }): RelayObservable<GraphQLResponse>;
+    executeMutation({
+        operation,
+        optimisticResponse,
+        optimisticUpdater,
+        updater,
+        uploadables,
+    }: {
+        operation: OperationDescriptor;
+        optimisticUpdater?: SelectorStoreUpdater | null | undefined;
+        optimisticResponse?: { [key: string]: any } | null | undefined;
+        updater?: SelectorStoreUpdater | null | undefined;
+        uploadables?: UploadableMap | null | undefined;
+    }): RelayObservable<GraphQLResponse>;
+    executeWithSource({
+        operation,
+        source,
+    }: {
+        operation: OperationDescriptor;
+        source: RelayObservable<GraphQLResponse>;
+    }): RelayObservable<GraphQLResponse>;
+}

package/store/RelayModernEnvironment.js.flow

@@ -64,28 +64,29 @@ const RelayRecordSource = require('./RelayRecordSource');
 const invariant = require('invariant');
 
 export type EnvironmentConfig = {
-  +configName?: string,
-  +handlerProvider?: ?HandlerProvider,
-  +treatMissingFieldsAsNull?: boolean,
-  +log?: ?LogFunction,
-  +operationLoader?: ?OperationLoader,
-  +network: INetwork,
-  +normalizeResponse?: ?NormalizeResponseFunction,
-  +scheduler?: ?TaskScheduler,
-  +store?: Store,
-  +missingFieldHandlers?: ?$ReadOnlyArray<MissingFieldHandler>,
-  +operationTracker?: ?OperationTracker,
-  +getDataID?: ?GetDataID,
-  +UNSTABLE_defaultRenderPolicy?: ?RenderPolicy,
-  +options?: mixed,
-  +isServer?: boolean,
-  +relayFieldLogger?: ?RelayFieldLogger,
-  +shouldProcessClientComponents?: ?boolean,
+  readonly configName?: string,
+  readonly handlerProvider?: ?HandlerProvider,
+  readonly treatMissingFieldsAsNull?: boolean,
+  readonly deferDeduplicatedFields?: boolean,
+  readonly log?: ?LogFunction,
+  readonly operationLoader?: ?OperationLoader,
+  readonly network: INetwork,
+  readonly normalizeResponse?: ?NormalizeResponseFunction,
+  readonly scheduler?: ?TaskScheduler,
+  readonly store?: Store,
+  readonly missingFieldHandlers?: ?ReadonlyArray<MissingFieldHandler>,
+  readonly operationTracker?: ?OperationTracker,
+  readonly getDataID?: ?GetDataID,
+  readonly UNSTABLE_defaultRenderPolicy?: ?RenderPolicy,
+  readonly options?: unknown,
+  readonly isServer?: boolean,
+  readonly relayFieldLogger?: ?RelayFieldLogger,
+  readonly shouldProcessClientComponents?: ?boolean,
 };
 
 class RelayModernEnvironment implements IEnvironment {
   __log: LogFunction;
-  +_defaultRenderPolicy: RenderPolicy;
+  readonly _defaultRenderPolicy: RenderPolicy;
   _operationLoader: ?OperationLoader;
   _shouldProcessClientComponents: ?boolean;
   _network: INetwork;
@@ -93,19 +94,21 @@ class RelayModernEnvironment implements IEnvironment {
   _scheduler: ?TaskScheduler;
   _store: Store;
   configName: ?string;
-  _missingFieldHandlers: $ReadOnlyArray<MissingFieldHandler>;
+  _missingFieldHandlers: ReadonlyArray<MissingFieldHandler>;
   _operationTracker: OperationTracker;
   _getDataID: GetDataID;
   _treatMissingFieldsAsNull: boolean;
+  _deferDeduplicatedFields: boolean;
   _operationExecutions: Map<string, ActiveState>;
-  +options: mixed;
-  +_isServer: boolean;
+  readonly options: unknown;
+  readonly _isServer: boolean;
   relayFieldLogger: RelayFieldLogger;
   _normalizeResponse: NormalizeResponseFunction;
 
   constructor(config: EnvironmentConfig) {
     this.configName = config.configName;
     this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull === true;
+    this._deferDeduplicatedFields = config.deferDeduplicatedFields === true;
     const operationLoader = config.operationLoader;
     if (__DEV__) {
       if (operationLoader != null) {
@@ -122,9 +125,9 @@ class RelayModernEnvironment implements IEnvironment {
     const store =
       config.store ??
       new RelayModernStore(new RelayRecordSource(), {
+        getDataID: config.getDataID,
         log: config.log,
         operationLoader: config.operationLoader,
-        getDataID: config.getDataID,
         shouldProcessClientComponents: config.shouldProcessClientComponents,
       });
 
@@ -150,12 +153,12 @@ class RelayModernEnvironment implements IEnvironment {
     this._isServer = config.isServer ?? false;
     this._normalizeResponse = config.normalizeResponse ?? normalizeResponse;
 
-    (this: any).__setNet = newNet =>
+    (this as any).__setNet = newNet =>
       (this._network = wrapNetworkWithLogObserver(this, newNet));
 
     if (__DEV__) {
       const {inspect} = require('./StoreInspector');
-      (this: any).DEBUG_inspect = (dataID: ?string) => inspect(this, dataID);
+      (this as any).DEBUG_inspect = (dataID: ?string) => inspect(this, dataID);
     }
 
     this._operationTracker =
@@ -224,7 +227,7 @@ class RelayModernEnvironment implements IEnvironment {
     });
   }
 
-  applyMutation<TMutation: MutationParameters>(
+  applyMutation<TMutation extends MutationParameters>(
     optimisticConfig: OptimisticResponseConfig<TMutation>,
   ): Disposable {
     const subscription = this._execute({
@@ -256,7 +259,7 @@ class RelayModernEnvironment implements IEnvironment {
     this._execute({
       createSource: () => RelayObservable.from({data: payload}),
       isClientPayload: true,
-      operation: operation,
+      operation,
       optimisticConfig: null,
       updater: null,
     }).subscribe({});
@@ -284,18 +287,28 @@ class RelayModernEnvironment implements IEnvironment {
     return this._store.retain(operation);
   }
 
+  experimental_batchUpdates(callback: () => void): void {
+    // $FlowFixMe[prop-missing] - experimental method not on Store interface
+    const batchFn = this._store.experimental_batchUpdates;
+    invariant(
+      typeof batchFn === 'function',
+      'RelayModernEnvironment: The current store does not support experimental_batchUpdates.',
+    );
+    // We must use .call to preserve Flow's narrowing from the above typeof check.
+    batchFn.call(this._store, callback);
+  }
+
   isServer(): boolean {
     return this._isServer;
   }
 
   _checkSelectorAndHandleMissingFields(
     operation: OperationDescriptor,
-    handlers: $ReadOnlyArray<MissingFieldHandler>,
+    handlers: ReadonlyArray<MissingFieldHandler>,
   ): OperationAvailability {
     const target = RelayRecordSource.create();
     const source = this._store.getSource();
     const result = this._store.check(operation, {
-      handlers,
       defaultActorIdentifier: INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
       getSourceForActor(actorIdentifier: ActorIdentifier) {
         assertInternalActorIdentifier(actorIdentifier);
@@ -305,6 +318,7 @@ class RelayModernEnvironment implements IEnvironment {
         assertInternalActorIdentifier(actorIdentifier);
         return target;
       },
+      handlers,
     });
     if (target.size() > 0) {
       this._scheduleUpdates(() => {
@@ -365,7 +379,7 @@ class RelayModernEnvironment implements IEnvironment {
    * Note: Observables are lazy, so calling this method will do nothing until
    * the result is subscribed to: environment.execute({...}).subscribe({...}).
    */
-  executeSubscription<TMutation: MutationParameters>({
+  executeSubscription<TMutation extends MutationParameters>({
     operation,
     updater,
   }: {
@@ -397,7 +411,7 @@ class RelayModernEnvironment implements IEnvironment {
    * the result is subscribed to:
    * environment.executeMutation({...}).subscribe({...}).
    */
-  executeMutation<TMutation: MutationParameters>({
+  executeMutation<TMutation extends MutationParameters>({
     operation,
     optimisticResponse,
     optimisticUpdater,
@@ -407,7 +421,7 @@ class RelayModernEnvironment implements IEnvironment {
     let optimisticConfig;
     if (optimisticResponse || optimisticUpdater) {
       optimisticConfig = {
-        operation: operation,
+        operation,
         response: optimisticResponse,
         updater: optimisticUpdater,
       };
@@ -455,11 +469,11 @@ class RelayModernEnvironment implements IEnvironment {
     });
   }
 
-  toJSON(): mixed {
+  toJSON(): unknown {
     return `RelayModernEnvironment(${this.configName ?? ''})`;
   }
 
-  _execute<TMutation: MutationParameters>({
+  _execute<TMutation extends MutationParameters>({
     createSource,
     isClientPayload,
     operation,
@@ -478,30 +492,31 @@ class RelayModernEnvironment implements IEnvironment {
       const executor = OperationExecutor.execute<$FlowFixMe>({
         actorIdentifier: INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
         getDataID: this._getDataID,
+        getPublishQueue(actorIdentifier: ActorIdentifier) {
+          assertInternalActorIdentifier(actorIdentifier);
+          return publishQueue;
+        },
+        getStore(actorIdentifier: ActorIdentifier) {
+          assertInternalActorIdentifier(actorIdentifier);
+          return store;
+        },
         isClientPayload,
         log: this.__log,
+        normalizeResponse: this._normalizeResponse,
         operation,
         operationExecutions: this._operationExecutions,
         operationLoader: this._operationLoader,
         operationTracker: this._operationTracker,
         optimisticConfig,
-        getPublishQueue(actorIdentifier: ActorIdentifier) {
-          assertInternalActorIdentifier(actorIdentifier);
-          return publishQueue;
-        },
         scheduler: this._scheduler,
         shouldProcessClientComponents: this._shouldProcessClientComponents,
         sink,
         // NOTE: Some product tests expect `Network.execute` to be called only
         //       when the Observable is executed.
         source: createSource(),
-        getStore(actorIdentifier: ActorIdentifier) {
-          assertInternalActorIdentifier(actorIdentifier);
-          return store;
-        },
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
+        deferDeduplicatedFields: this._deferDeduplicatedFields,
         updater,
-        normalizeResponse: this._normalizeResponse,
       });
       return () => executor.cancel();
     });
@@ -520,7 +535,7 @@ function operationHasClientAbstractTypes(
 // Add a sigil for detection by `isRelayModernEnvironment()` to avoid a
 // realm-specific instanceof check, and to aid in module tree-shaking to
 // avoid requiring all of RelayRuntime just to detect its environment.
-(RelayModernEnvironment: any).prototype['@@RelayModernEnvironment'] = true;
+(RelayModernEnvironment as any).prototype['@@RelayModernEnvironment'] = true;
 
 function emptyFunction() {}
 

package/store/RelayModernFragmentSpecResolver.js.flow

@@ -43,7 +43,7 @@ const areEqual = require('areEqual');
 const invariant = require('invariant');
 const warning = require('warning');
 
-type Props = {[key: string]: mixed, ...};
+type Props = {[key: string]: unknown, ...};
 type Resolvers = {
   [key: string]: ?(SelectorListResolver | SelectorResolver),
   ...

package/store/RelayModernOperationDescriptor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { ConcreteRequest } from '../util/RelayConcreteNode';
+import {CacheConfig, DataID, Variables} from '../util/RelayRuntimeTypes';
+import {OperationDescriptor, RequestDescriptor} from './RelayStoreTypes';
+/**
+ * Creates an instance of the `OperationDescriptor` type defined in
+ * `RelayStoreTypes` given an operation and some variables. The input variables
+ * are filtered to exclude variables that do not match defined arguments on the
+ * operation, and default values are populated for null values.
+ */
+export function createOperationDescriptor(
+    request: ConcreteRequest,
+    variables: Variables,
+    cacheConfig?: CacheConfig | null,
+    dataID?: DataID,
+): OperationDescriptor;
+
+export function createRequestDescriptor(
+    request: ConcreteRequest,
+    variables: Variables,
+    cacheConfig?: CacheConfig | null,
+): RequestDescriptor;

package/store/RelayModernOperationDescriptor.js.flow

@@ -39,7 +39,7 @@ const invariant = require('invariant');
  * are filtered to exclude variables that do not match defined arguments on the
  * operation, and default values are populated for null values.
  */
-function createOperationDescriptor<TQuery: OperationType>(
+function createOperationDescriptor<TQuery extends OperationType>(
   request: ConcreteRequest,
   variables: VariablesOf<TQuery>,
   cacheConfig?: ?CacheConfig,