relay-runtime 10.0.0 → 10.1.2

package/store/RelayModernQueryExecutor.js.flow

@@ -19,6 +19,7 @@ const RelayObservable = require('../network/RelayObservable');
 const RelayRecordSource = require('./RelayRecordSource');
 const RelayResponseNormalizer = require('./RelayResponseNormalizer');
 
+const getOperation = require('../util/getOperation');
 const invariant = require('invariant');
 const stableCopy = require('../util/stableCopy');
 const warning = require('warning');
@@ -46,6 +47,7 @@ import type {
   OptimisticResponseConfig,
   OptimisticUpdate,
   PublishQueue,
+  ReactFlightPayloadDeserializer,
   Record,
   RelayResponsePayload,
   SelectorStoreUpdater,
@@ -54,10 +56,12 @@ import type {
 } from '../store/RelayStoreTypes';
 import type {
   NormalizationLinkedField,
-  NormalizationSplitOperation,
+  NormalizationOperation,
+  NormalizationRootNode,
   NormalizationSelectableNode,
+  NormalizationSplitOperation,
 } from '../util/NormalizationNode';
-import type {DataID, Variables} from '../util/RelayRuntimeTypes';
+import type {DataID, Variables, Disposable} from '../util/RelayRuntimeTypes';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {NormalizationOptions} from './RelayResponseNormalizer';
 
@@ -70,6 +74,7 @@ export type ExecuteConfig = {|
   +operationTracker?: ?OperationTracker,
   +optimisticConfig: ?OptimisticResponseConfig,
   +publishQueue: PublishQueue,
+  +reactFlightPayloadDeserializer?: ?ReactFlightPayloadDeserializer,
   +scheduler?: ?TaskScheduler,
   +sink: Sink<GraphQLResponse>,
   +source: RelayObservable<GraphQLResponse>,
@@ -126,6 +131,7 @@ class Executor {
   _optimisticUpdates: null | Array<OptimisticUpdate>;
   _pendingModulePayloadsCount: number;
   _publishQueue: PublishQueue;
+  _reactFlightPayloadDeserializer: ?ReactFlightPayloadDeserializer;
   _scheduler: ?TaskScheduler;
   _sink: Sink<GraphQLResponse>;
   _source: Map<
@@ -136,6 +142,7 @@ class Executor {
   _store: Store;
   _subscriptions: Map<number, Subscription>;
   _updater: ?SelectorStoreUpdater;
+  _retainDisposable: ?Disposable;
   +_isClientPayload: boolean;
 
   constructor({
@@ -153,6 +160,7 @@ class Executor {
     treatMissingFieldsAsNull,
     getDataID,
     isClientPayload,
+    reactFlightPayloadDeserializer,
   }: ExecuteConfig): void {
     this._getDataID = getDataID;
     this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;
@@ -175,6 +183,7 @@ class Executor {
     this._subscriptions = new Map();
     this._updater = updater;
     this._isClientPayload = isClientPayload === true;
+    this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;
 
     const id = this._nextSubscriptionId++;
     source.subscribe({
@@ -223,6 +232,10 @@ class Executor {
     }
     this._incrementalResults.clear();
     this._completeOperationTracker();
+    if (this._retainDisposable) {
+      this._retainDisposable.dispose();
+      this._retainDisposable = null;
+    }
   }
 
   _updateActiveState(): void {
@@ -423,19 +436,22 @@ class Executor {
 
     // In theory this doesn't preserve the ordering of the batch.
     // The idea is that a batch is always:
-    //  * at-most one non-incremental payload
-    //  * followed zero or more incremental payloads
+    //  * at most one non-incremental payload
+    //  * followed by zero or more incremental payloads
     // The non-incremental payload can appear if the server sends a batch
-    // w the initial payload followed by some early-to-resolve incremental
+    // with the initial payload followed by some early-to-resolve incremental
     // payloads (although, can that even happen?)
     if (nonIncrementalResponses.length > 0) {
       const payloadFollowups = this._processResponses(nonIncrementalResponses);
-      // Please note, that we're passing `this._operation` to the publish
+      // Please note that we're passing `this._operation` to the publish
       // queue here, which will later passed to the store (via notify)
-      // to indicate that this is an operation that cause the store to update
+      // to indicate that this is an operation that caused the store to update
       const updatedOwners = this._publishQueue.run(this._operation);
       this._updateOperationTracker(updatedOwners);
       this._processPayloadFollowups(payloadFollowups);
+      if (this._incrementalPayloadsPending && !this._retainDisposable) {
+        this._retainDisposable = this._store.retain(this._operation);
+      }
     }
 
     if (incrementalResponses.length > 0) {
@@ -474,6 +490,7 @@ class Executor {
         {
           getDataID: this._getDataID,
           path: [],
+          reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
           treatMissingFieldsAsNull,
         },
       );
@@ -525,11 +542,11 @@ class Executor {
             moduleImportPayload,
           );
         } else {
-          const moduleImportOptimisitcUpdates = this._processOptimisticModuleImport(
+          const moduleImportOptimisticUpdates = this._processOptimisticModuleImport(
             operation,
             moduleImportPayload,
           );
-          optimisticUpdates.push(...moduleImportOptimisitcUpdates);
+          optimisticUpdates.push(...moduleImportOptimisticUpdates);
         }
       }
     }
@@ -551,15 +568,17 @@ class Executor {
       {
         getDataID: this._getDataID,
         path: moduleImportPayload.path,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
     );
   }
 
   _processOptimisticModuleImport(
-    operation: NormalizationSplitOperation,
+    normalizationRootNode: NormalizationRootNode,
     moduleImportPayload: ModuleImportPayload,
   ): $ReadOnlyArray<OptimisticUpdate> {
+    const operation = getOperation(normalizationRootNode);
     const optimisticUpdates = [];
     const modulePayload = this._normalizeModuleImport(
       moduleImportPayload,
@@ -585,22 +604,22 @@ class Executor {
         if (operation == null || this._state !== 'started') {
           return;
         }
-        const moduleImportOptimisitcUpdates = this._processOptimisticModuleImport(
+        const moduleImportOptimisticUpdates = this._processOptimisticModuleImport(
           operation,
           moduleImportPayload,
         );
-        moduleImportOptimisitcUpdates.forEach(update =>
+        moduleImportOptimisticUpdates.forEach(update =>
           this._publishQueue.applyUpdate(update),
         );
         if (this._optimisticUpdates == null) {
           warning(
             false,
-            'RelayModernQueryExecutor: Unexpected ModuleImport optimisitc ' +
+            'RelayModernQueryExecutor: Unexpected ModuleImport optimistic ' +
               'update in operation %s.' +
               this._operation.request.node.params.name,
           );
         } else {
-          this._optimisticUpdates.push(...moduleImportOptimisitcUpdates);
+          this._optimisticUpdates.push(...moduleImportOptimisticUpdates);
           this._publishQueue.run();
         }
       });
@@ -624,8 +643,9 @@ class Executor {
         ROOT_TYPE,
         {
           getDataID: this._getDataID,
-          treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
           path: [],
+          reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
+          treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
         },
       );
       this._publishQueue.commitPayload(
@@ -737,13 +757,12 @@ class Executor {
     moduleImportPayload: ModuleImportPayload,
     operationLoader: OperationLoader,
   ): void {
-    const syncOperation = operationLoader.get(
-      moduleImportPayload.operationReference,
-    );
-    if (syncOperation != null) {
+    const node = operationLoader.get(moduleImportPayload.operationReference);
+    if (node != null) {
+      const operation = getOperation(node);
       // If the operation module is available synchronously, normalize the
       // data synchronously.
-      this._handleModuleImportPayload(moduleImportPayload, syncOperation);
+      this._handleModuleImportPayload(moduleImportPayload, operation);
       this._maybeCompleteSubscriptionOperationTracking();
     } else {
       // Otherwise load the operation module and schedule a task to normalize
@@ -766,10 +785,13 @@ class Executor {
             .then(resolve, reject);
         }),
       )
-        .map((operation: ?NormalizationSplitOperation) => {
+        .map((operation: ?NormalizationRootNode) => {
           if (operation != null) {
             this._schedule(() => {
-              this._handleModuleImportPayload(moduleImportPayload, operation);
+              this._handleModuleImportPayload(
+                moduleImportPayload,
+                getOperation(operation),
+              );
             });
           }
         })
@@ -789,7 +811,7 @@ class Executor {
 
   _handleModuleImportPayload(
     moduleImportPayload: ModuleImportPayload,
-    operation: NormalizationSplitOperation,
+    operation: NormalizationSplitOperation | NormalizationOperation,
   ): void {
     const relayPayload = this._normalizeModuleImport(
       moduleImportPayload,
@@ -997,6 +1019,7 @@ class Executor {
       {
         getDataID: this._getDataID,
         path: placeholder.path,
+        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
         treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
       },
     );
@@ -1211,6 +1234,7 @@ class Executor {
     const relayPayload = normalizeResponse(response, selector, typeName, {
       getDataID: this._getDataID,
       path: [...normalizationPath, responseKey, String(itemIndex)],
+      reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,
       treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,
     });
     return {

package/store/RelayModernStore.js.flow

@@ -13,18 +13,20 @@
 'use strict';
 
 const DataChecker = require('./DataChecker');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const RelayModernRecord = require('./RelayModernRecord');
 const RelayOptimisticRecordSource = require('./RelayOptimisticRecordSource');
 const RelayProfiler = require('../util/RelayProfiler');
 const RelayReader = require('./RelayReader');
 const RelayReferenceMarker = require('./RelayReferenceMarker');
+const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
+const RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
+const RelayStoreSubscriptionsUsingMapByID = require('./RelayStoreSubscriptionsUsingMapByID');
 const RelayStoreUtils = require('./RelayStoreUtils');
 
 const deepFreeze = require('../util/deepFreeze');
 const defaultGetDataID = require('./defaultGetDataID');
-const hasOverlappingIDs = require('./hasOverlappingIDs');
 const invariant = require('invariant');
-const recycleNodesInto = require('../util/recycleNodesInto');
 const resolveImmediate = require('../util/resolveImmediate');
 
 const {ROOT_ID, ROOT_TYPE} = require('./RelayStoreUtils');
@@ -45,6 +47,7 @@ import type {
   SingularReaderSelector,
   Snapshot,
   Store,
+  StoreSubscriptions,
   UpdatedRecords,
 } from './RelayStoreTypes';
 
@@ -53,14 +56,6 @@ export opaque type InvalidationState = {|
   invalidations: Map<DataID, ?number>,
 |};
 
-type Subscription = {
-  callback: (snapshot: Snapshot) => void,
-  snapshot: Snapshot,
-  stale: boolean,
-  backup: ?Snapshot,
-  ...
-};
-
 type InvalidationSubscription = {|
   callback: () => void,
   invalidationState: InvalidationState,
@@ -90,7 +85,7 @@ class RelayModernStore implements Store {
   _globalInvalidationEpoch: ?number;
   _invalidationSubscriptions: Set<InvalidationSubscription>;
   _invalidatedRecordIDs: Set<DataID>;
-  _log: ?LogFunction;
+  __log: ?LogFunction;
   _queryCacheExpirationTime: ?number;
   _operationLoader: ?OperationLoader;
   _optimisticSource: ?MutableRecordSource;
@@ -106,7 +101,7 @@ class RelayModernStore implements Store {
     |},
   >;
   _shouldScheduleGC: boolean;
-  _subscriptions: Set<Subscription>;
+  _storeSubscriptions: StoreSubscriptions;
   _updatedRecordIDs: UpdatedRecords;
 
   constructor(
@@ -141,7 +136,7 @@ class RelayModernStore implements Store {
     this._globalInvalidationEpoch = null;
     this._invalidationSubscriptions = new Set();
     this._invalidatedRecordIDs = new Set();
-    this._log = options?.log ?? null;
+    this.__log = options?.log ?? null;
     this._queryCacheExpirationTime = options?.queryCacheExpirationTime;
     this._operationLoader = options?.operationLoader ?? null;
     this._optimisticSource = null;
@@ -149,7 +144,10 @@ class RelayModernStore implements Store {
     this._releaseBuffer = [];
     this._roots = new Map();
     this._shouldScheduleGC = false;
-    this._subscriptions = new Set();
+    this._storeSubscriptions =
+      RelayFeatureFlags.ENABLE_STORE_SUBSCRIPTIONS_REFACTOR === true
+        ? new RelayStoreSubscriptionsUsingMapByID()
+        : new RelayStoreSubscriptions();
     this._updatedRecordIDs = {};
 
     initializeRecordSource(this._recordSource);
@@ -232,7 +230,7 @@ class RelayModernStore implements Store {
 
         if (rootEntryIsStale) {
           this._roots.delete(id);
-          this._scheduleGC();
+          this.scheduleGC();
         } else {
           this._releaseBuffer.push(id);
 
@@ -242,7 +240,7 @@ class RelayModernStore implements Store {
           if (this._releaseBuffer.length > this._gcReleaseBufferSize) {
             const _id = this._releaseBuffer.shift();
             this._roots.delete(_id);
-            this._scheduleGC();
+            this.scheduleGC();
           }
         }
       }
@@ -285,7 +283,7 @@ class RelayModernStore implements Store {
     sourceOperation?: OperationDescriptor,
     invalidateStore?: boolean,
   ): $ReadOnlyArray<RequestDescriptor> {
-    const log = this._log;
+    const log = this.__log;
     if (log != null) {
       log({
         name: 'store.notify.start',
@@ -302,12 +300,11 @@ class RelayModernStore implements Store {
 
     const source = this.getSource();
     const updatedOwners = [];
-    this._subscriptions.forEach(subscription => {
-      const owner = this._updateSubscription(source, subscription);
-      if (owner != null) {
-        updatedOwners.push(owner);
-      }
-    });
+    this._storeSubscriptions.updateSubscriptions(
+      source,
+      this._updatedRecordIDs,
+      updatedOwners,
+    );
     this._invalidationSubscriptions.forEach(subscription => {
       this._updateInvalidationSubscription(
         subscription,
@@ -375,7 +372,7 @@ class RelayModernStore implements Store {
     );
     // NOTE: log *after* processing the source so that even if a bad log function
     // mutates the source, it doesn't affect Relay processing of it.
-    const log = this._log;
+    const log = this.__log;
     if (log != null) {
       log({
         name: 'store.publish',
@@ -389,12 +386,7 @@ class RelayModernStore implements Store {
     snapshot: Snapshot,
     callback: (snapshot: Snapshot) => void,
   ): Disposable {
-    const subscription = {backup: null, callback, snapshot, stale: false};
-    const dispose = () => {
-      this._subscriptions.delete(subscription);
-    };
-    this._subscriptions.add(subscription);
-    return {dispose};
+    return this._storeSubscriptions.subscribe(snapshot, callback);
   }
 
   holdGC(): Disposable {
@@ -407,7 +399,7 @@ class RelayModernStore implements Store {
       if (this._gcHoldCounter > 0) {
         this._gcHoldCounter--;
         if (this._gcHoldCounter === 0 && this._shouldScheduleGC) {
-          this._scheduleGC();
+          this.scheduleGC();
           this._shouldScheduleGC = false;
         }
       }
@@ -424,42 +416,6 @@ class RelayModernStore implements Store {
     return this._updatedRecordIDs;
   }
 
-  // Returns the owner (RequestDescriptor) if the subscription was affected by the
-  // latest update, or null if it was not affected.
-  _updateSubscription(
-    source: RecordSource,
-    subscription: Subscription,
-  ): ?RequestDescriptor {
-    const {backup, callback, snapshot, stale} = subscription;
-    const hasOverlappingUpdates = hasOverlappingIDs(
-      snapshot.seenRecords,
-      this._updatedRecordIDs,
-    );
-    if (!stale && !hasOverlappingUpdates) {
-      return;
-    }
-    let nextSnapshot: Snapshot =
-      hasOverlappingUpdates || !backup
-        ? RelayReader.read(source, snapshot.selector)
-        : backup;
-    const nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);
-    nextSnapshot = ({
-      data: nextData,
-      isMissingData: nextSnapshot.isMissingData,
-      seenRecords: nextSnapshot.seenRecords,
-      selector: nextSnapshot.selector,
-    }: Snapshot);
-    if (__DEV__) {
-      deepFreeze(nextSnapshot);
-    }
-    subscription.snapshot = nextSnapshot;
-    subscription.stale = false;
-    if (nextSnapshot.data !== snapshot.data) {
-      callback(nextSnapshot);
-      return snapshot.selector.owner;
-    }
-  }
-
   lookupInvalidationState(dataIDs: $ReadOnlyArray<DataID>): InvalidationState {
     const invalidations = new Map();
     dataIDs.forEach(dataID => {
@@ -533,35 +489,13 @@ class RelayModernStore implements Store {
       'RelayModernStore: Unexpected call to snapshot() while a previous ' +
         'snapshot exists.',
     );
-    const log = this._log;
+    const log = this.__log;
     if (log != null) {
       log({
         name: 'store.snapshot',
       });
     }
-    this._subscriptions.forEach(subscription => {
-      // Backup occurs after writing a new "final" payload(s) and before (re)applying
-      // optimistic changes. Each subscription's `snapshot` represents what was *last
-      // published to the subscriber*, which notably may include previous optimistic
-      // updates. Therefore a subscription can be in any of the following states:
-      // - stale=true: This subscription was restored to a different value than
-      //   `snapshot`. That means this subscription has changes relative to its base,
-      //   but its base has changed (we just applied a final payload): recompute
-      //   a backup so that we can later restore to the state the subscription
-      //   should be in.
-      // - stale=false: This subscription was restored to the same value than
-      //   `snapshot`. That means this subscription does *not* have changes relative
-      //   to its base, so the current `snapshot` is valid to use as a backup.
-      if (!subscription.stale) {
-        subscription.backup = subscription.snapshot;
-        return;
-      }
-      const snapshot = subscription.snapshot;
-      const backup = RelayReader.read(this.getSource(), snapshot.selector);
-      const nextData = recycleNodesInto(snapshot.data, backup.data);
-      (backup: $FlowFixMe).data = nextData; // backup owns the snapshot and can safely mutate
-      subscription.backup = backup;
-    });
+    this._storeSubscriptions.snapshotSubscriptions(this.getSource());
     if (this._gcRun) {
       this._gcRun = null;
       this._shouldScheduleGC = true;
@@ -577,7 +511,7 @@ class RelayModernStore implements Store {
       'RelayModernStore: Unexpected call to restore(), expected a snapshot ' +
         'to exist (make sure to call snapshot()).',
     );
-    const log = this._log;
+    const log = this.__log;
     if (log != null) {
       log({
         name: 'store.restore',
@@ -585,28 +519,12 @@ class RelayModernStore implements Store {
     }
     this._optimisticSource = null;
     if (this._shouldScheduleGC) {
-      this._scheduleGC();
+      this.scheduleGC();
     }
-    this._subscriptions.forEach(subscription => {
-      const backup = subscription.backup;
-      subscription.backup = null;
-      if (backup) {
-        if (backup.data !== subscription.snapshot.data) {
-          subscription.stale = true;
-        }
-        subscription.snapshot = {
-          data: subscription.snapshot.data,
-          isMissingData: backup.isMissingData,
-          seenRecords: backup.seenRecords,
-          selector: backup.selector,
-        };
-      } else {
-        subscription.stale = true;
-      }
-    });
+    this._storeSubscriptions.restoreSubscriptions();
   }
 
-  _scheduleGC() {
+  scheduleGC() {
     if (this._gcHoldCounter > 0) {
       this._shouldScheduleGC = true;
       return;
@@ -664,7 +582,7 @@ class RelayModernStore implements Store {
         }
       }
 
-      const log = this._log;
+      const log = this.__log;
       if (log != null) {
         log({
           name: 'store.gc',
@@ -701,7 +619,7 @@ function initializeRecordSource(target: MutableRecordSource) {
 /**
  * Updates the target with information from source, also updating a mapping of
  * which records in the target were changed as a result.
- * Additionally, will marc records as invalidated at the current write epoch
+ * Additionally, will mark records as invalidated at the current write epoch
  * given the set of record ids marked as stale in this update.
  */
 function updateTargetFromSource(
@@ -770,7 +688,15 @@ function updateTargetFromSource(
       }
     }
     if (sourceRecord && targetRecord) {
-      const nextRecord = RelayModernRecord.update(targetRecord, sourceRecord);
+      // ReactFlightClientResponses are lazy and only materialize when readRoot
+      // is called when we read the field, so if the record is a Flight field
+      // we always use the new record's data regardless of whether
+      // it actually changed. Let React take care of reconciliation instead.
+      const nextRecord =
+        RelayModernRecord.getType(targetRecord) ===
+        RelayStoreReactFlightUtils.REACT_FLIGHT_TYPE_NAME
+          ? sourceRecord
+          : RelayModernRecord.update(targetRecord, sourceRecord);
       if (nextRecord !== targetRecord) {
         // Prevent mutation of a record from outside the store.
         if (__DEV__) {

package/store/RelayPublishQueue.js.flow

@@ -186,7 +186,7 @@ class RelayPublishQueue implements PublishQueue {
       warning(
         this._isRunning !== true,
         'A store update was detected within another store update. Please ' +
-          'make sure new store updates aren’t being executed within an ' +
+          "make sure new store updates aren't being executed within an " +
           'updater function for a different update.',
       );
       this._isRunning = true;