relay-runtime 20.1.0 → 21.0.0

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.js.flow

@@ -67,17 +67,18 @@ export type EnvironmentConfig = {
   +configName?: string,
   +handlerProvider?: ?HandlerProvider,
   +treatMissingFieldsAsNull?: boolean,
+  +deferDeduplicatedFields?: boolean,
   +log?: ?LogFunction,
   +operationLoader?: ?OperationLoader,
   +network: INetwork,
   +normalizeResponse?: ?NormalizeResponseFunction,
   +scheduler?: ?TaskScheduler,
   +store?: Store,
-  +missingFieldHandlers?: ?$ReadOnlyArray<MissingFieldHandler>,
+  +missingFieldHandlers?: ?ReadonlyArray<MissingFieldHandler>,
   +operationTracker?: ?OperationTracker,
   +getDataID?: ?GetDataID,
   +UNSTABLE_defaultRenderPolicy?: ?RenderPolicy,
-  +options?: mixed,
+  +options?: unknown,
   +isServer?: boolean,
   +relayFieldLogger?: ?RelayFieldLogger,
   +shouldProcessClientComponents?: ?boolean,
@@ -93,12 +94,13 @@ 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;
+  +options: unknown;
   +_isServer: boolean;
   relayFieldLogger: RelayFieldLogger;
   _normalizeResponse: NormalizeResponseFunction;
@@ -106,6 +108,7 @@ class RelayModernEnvironment implements IEnvironment {
   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.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,

package/store/RelayModernRecord.js.flow

@@ -37,7 +37,7 @@ const warning = require('warning');
 
 export type StorageKey = Exclude<string, typeof ERRORS_KEY>;
 
-type RelayFieldErrors = {[StorageKey]: $ReadOnlyArray<TRelayFieldError>};
+type RelayFieldErrors = {[StorageKey]: ReadonlyArray<TRelayFieldError>};
 
 export type RecordJSON = {
   /**
@@ -45,7 +45,7 @@ export type RecordJSON = {
    * not support types with multiple indexers.
    */
   __errors?: RelayFieldErrors,
-  [StorageKey]: mixed,
+  [StorageKey]: unknown,
   ...
 };
 
@@ -147,7 +147,7 @@ function create(dataID: DataID, typeName: string): Record {
  *
  * Convert the JSON representation of a record into a record.
  */
-function fromObject<TMaybe: ?empty = empty>(
+function fromObject<TMaybe extends ?empty = empty>(
   json: RecordJSON | TMaybe,
 ): Record | TMaybe {
   return json;
@@ -159,7 +159,7 @@ function fromObject<TMaybe: ?empty = empty>(
  * Get the record's `id` if available or the client-generated identifier.
  */
 function getDataID(record: Record): DataID {
-  return (record[ID_KEY]: any);
+  return record[ID_KEY] as any;
 }
 
 /**
@@ -180,7 +180,7 @@ function getFields(record: Record): Array<StorageKey> {
  * Get the concrete type of the record.
  */
 function getType(record: Record): string {
-  return (record[TYPENAME_KEY]: any);
+  return record[TYPENAME_KEY] as any;
 }
 
 /**
@@ -191,7 +191,7 @@ function getType(record: Record): string {
 function getErrors(
   record: Record,
   storageKey: StorageKey,
-): $ReadOnlyArray<TRelayFieldError> | void {
+): ReadonlyArray<TRelayFieldError> | void {
   return record[ERRORS_KEY]?.[storageKey];
 }
 
@@ -200,7 +200,7 @@ function getErrors(
  *
  * Get a scalar (non-link) field value.
  */
-function getValue(record: Record, storageKey: StorageKey): mixed {
+function getValue(record: Record, storageKey: StorageKey): unknown {
   const value = record[storageKey];
   if (value && typeof value === 'object') {
     invariant(
@@ -252,7 +252,7 @@ function getLinkedRecordID(record: Record, storageKey: StorageKey): ?DataID {
           'getLinkedRecords() instead of getLinkedRecord()?'
       : '',
   );
-  // $FlowFixMe[incompatible-return]
+  // $FlowFixMe[incompatible-type]
   return link[REF_KEY];
 }
 
@@ -297,7 +297,7 @@ function getLinkedRecordIDs(
       : '',
   );
   // assume items of the array are ids
-  return (links[REFS_KEY]: any);
+  return links[REFS_KEY] as any;
 }
 
 /**
@@ -443,7 +443,7 @@ function merge(record1: Record, record2: Record): Record {
   if (ERRORS_KEY in record1 || ERRORS_KEY in record2) {
     const {[ERRORS_KEY]: errors1, ...fields1} = record1;
     const {[ERRORS_KEY]: errors2, ...fields2} = record2;
-    // $FlowIssue[cannot-spread-indexer]
+    // $FlowFixMe[cannot-spread-indexer]
     const updated: Record = {...fields1, ...fields2};
     if (errors1 == null && errors2 == null) {
       return updated;
@@ -465,7 +465,7 @@ function merge(record1: Record, record2: Record): Record {
     }
     return updated;
   } else {
-    // $FlowIssue[cannot-spread-indexer]
+    // $FlowFixMe[cannot-spread-indexer]
     return {...record1, ...record2};
   }
 }
@@ -488,7 +488,7 @@ function freeze(record: Record): void {
 function setErrors(
   record: Record,
   storageKey: StorageKey,
-  errors?: $ReadOnlyArray<TRelayFieldError>,
+  errors?: ReadonlyArray<TRelayFieldError>,
 ): void {
   if (__DEV__) {
     warning(
@@ -523,7 +523,11 @@ function setErrors(
  *
  * Set the value of a storageKey to a scalar.
  */
-function setValue(record: Record, storageKey: StorageKey, value: mixed): void {
+function setValue(
+  record: Record,
+  storageKey: StorageKey,
+  value: unknown,
+): void {
   if (__DEV__) {
     const prevID = getDataID(record);
     if (storageKey === ID_KEY) {
@@ -629,7 +633,7 @@ function getActorLinkedRecordID(
     JSON.stringify(link),
   );
 
-  return [(link[ACTOR_IDENTIFIER_KEY]: any), (link[REF_KEY]: any)];
+  return [link[ACTOR_IDENTIFIER_KEY] as any, link[REF_KEY] as any];
 }
 
 function getResolverLinkedRecordID(record: Record, typeName: string): ?DataID {
@@ -682,12 +686,31 @@ function getResolverLinkedRecordIDs(
   });
 }
 
+/**
+ * @public
+ *
+ * Returns true if the value of a field differs between two records.
+ * Unlike getValue(), this works for all field types (scalar, linked, plural linked).
+ */
+function hasFieldChanged(
+  prevRecord: Record,
+  nextRecord: Record,
+  storageKey: StorageKey,
+): boolean {
+  if (!areEqual(prevRecord[storageKey], nextRecord[storageKey])) {
+    return true;
+  }
+  const prevErrors = prevRecord[ERRORS_KEY]?.[storageKey];
+  const nextErrors = nextRecord[ERRORS_KEY]?.[storageKey];
+  return !areEqual(prevErrors, nextErrors);
+}
+
 /**
  * @public
  *
  * Convert a record to JSON.
  */
-function toJSON<TMaybe: ?empty = empty>(
+function toJSON<TMaybe extends ?empty = empty>(
   record: Record | TMaybe,
 ): RecordJSON | TMaybe {
   return record;
@@ -699,26 +722,27 @@ module.exports = {
   create,
   freeze,
   fromObject,
+  getActorLinkedRecordID,
   getDataID,
   getErrors,
   getFields,
   getInvalidationEpoch,
   getLinkedRecordID,
   getLinkedRecordIDs,
+  getResolverLinkedRecordID,
+  getResolverLinkedRecordIDs,
   getType,
   getValue,
-  hasValue,
+  hasFieldChanged,
   hasLinkedRecordID,
   hasLinkedRecordIDs,
+  hasValue,
   merge,
+  setActorLinkedRecordID,
   setErrors,
-  setValue,
   setLinkedRecordID,
   setLinkedRecordIDs,
-  update,
-  getActorLinkedRecordID,
-  setActorLinkedRecordID,
-  getResolverLinkedRecordID,
-  getResolverLinkedRecordIDs,
+  setValue,
   toJSON,
+  update,
 };