relay-runtime 0.0.0-main-1ac62c2b → 0.0.0-main-c9cf5515

package/experimental.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-1ac62c2b
+ * Relay v0.0.0-main-c9cf5515
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-1ac62c2b
+ * Relay v0.0.0-main-c9cf5515
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/lib/store/OperationExecutor.js

@@ -328,9 +328,20 @@ var Executor = /*#__PURE__*/function () {
         return ((_x$extensions = x.extensions) === null || _x$extensions === void 0 ? void 0 : _x$extensions.is_final) === true;
       });
       if (isFinal) {
-        this._state = 'loading_final';
-        this._updateActiveState();
-        this._incrementalPayloadsPending = false;
+        if (this._useExecTimeResolvers && this._state !== 'loading_final' && responses.some(function (x) {
+          var _x$extensions2;
+          return ((_x$extensions2 = x.extensions) === null || _x$extensions2 === void 0 ? void 0 : _x$extensions2.is_normalized) === true;
+        })) {
+          this._execTimeResolverResponseComplete = true;
+          if (this._isClientQuery) {
+            this._state = 'loading_final';
+          }
+          this._updateActiveState();
+        } else {
+          this._state = 'loading_final';
+          this._updateActiveState();
+          this._incrementalPayloadsPending = false;
+        }
       }
       this._sink.next(response);
       return;

package/lib/store/RelayModernStore.js

@@ -7,6 +7,7 @@ var _require = require('../multi-actor-environment/ActorIdentifier'),
   INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE = _require.INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
   assertInternalActorIdentifier = _require.assertInternalActorIdentifier;
 var deepFreeze = require('../util/deepFreeze');
+var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 var resolveImmediate = require('../util/resolveImmediate');
 var DataChecker = require('./DataChecker');
 var defaultGetDataID = require('./defaultGetDataID');
@@ -218,17 +219,33 @@ var RelayModernStore = /*#__PURE__*/function () {
         sourceOperation: sourceOperation
       });
     }
-    this._currentWriteEpoch++;
-    if (invalidateStore === true) {
-      this._globalInvalidationEpoch = this._currentWriteEpoch;
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+      this._currentWriteEpoch++;
+      if (invalidateStore === true) {
+        this._globalInvalidationEpoch = this._currentWriteEpoch;
+      }
+    }
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY || this._updatedRecordIDs.size > 0) {
+      this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
     }
-    this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
     var source = this.getSource();
     var updatedOwners = [];
-    this._storeSubscriptions.updateSubscriptions(source, this._updatedRecordIDs, updatedOwners, sourceOperation);
-    this._invalidationSubscriptions.forEach(function (subscription) {
-      _this3._updateInvalidationSubscription(subscription, invalidateStore === true);
-    });
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY || this._updatedRecordIDs.size > 0) {
+      this._storeSubscriptions.updateSubscriptions(source, this._updatedRecordIDs, updatedOwners, sourceOperation);
+    } else {
+      this._storeSubscriptions.updateStaleSubscriptions(source, this._updatedRecordIDs, updatedOwners, sourceOperation);
+    }
+    if (RelayFeatureFlags.OPTIMIZE_NOTIFY && (this._updatedRecordIDs.size > 0 || updatedOwners.length > 0 || this._invalidatedRecordIDs.size > 0 || invalidateStore === true || this._globalInvalidationEpoch === this._currentWriteEpoch)) {
+      this._currentWriteEpoch++;
+      if (invalidateStore === true) {
+        this._globalInvalidationEpoch = this._currentWriteEpoch;
+      }
+    }
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY || this._invalidatedRecordIDs.size > 0 || invalidateStore === true) {
+      this._invalidationSubscriptions.forEach(function (subscription) {
+        _this3._updateInvalidationSubscription(subscription, invalidateStore === true);
+      });
+    }
     if (sourceOperation != null) {
       var id = sourceOperation.request.identifier;
       var rootEntry = this._roots.get(id);

package/lib/store/RelayStoreSubscriptions.js

@@ -9,6 +9,7 @@ var RelayReader = require('./RelayReader');
 var RelayStoreSubscriptions = /*#__PURE__*/function () {
   function RelayStoreSubscriptions(log, resolverCache, resolverContext) {
     this._subscriptions = new Set();
+    this._staleSubscriptions = new Set();
     this.__log = log;
     this._resolverCache = resolverCache;
     this._resolverContext = resolverContext;
@@ -24,6 +25,9 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
     };
     var dispose = function dispose() {
       _this._subscriptions["delete"](subscription);
+      if (RelayFeatureFlags.OPTIMIZE_NOTIFY && subscription.stale) {
+        _this._staleSubscriptions["delete"](subscription);
+      }
     };
     this._subscriptions.add(subscription);
     return {
@@ -45,12 +49,16 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
     });
   };
   _proto.restoreSubscriptions = function restoreSubscriptions() {
+    var _this3 = this;
     this._subscriptions.forEach(function (subscription) {
       var backup = subscription.backup;
       subscription.backup = null;
       if (backup) {
         if (backup.data !== subscription.snapshot.data) {
           subscription.stale = true;
+          if (RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+            _this3._staleSubscriptions.add(subscription);
+          }
         }
         subscription.snapshot = {
           data: subscription.snapshot.data,
@@ -63,14 +71,27 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
         };
       } else {
         subscription.stale = true;
+        if (RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+          _this3._staleSubscriptions.add(subscription);
+        }
       }
     });
   };
   _proto.updateSubscriptions = function updateSubscriptions(source, updatedRecordIDs, updatedOwners, sourceOperation) {
-    var _this3 = this;
+    var _this4 = this;
     var hasUpdatedRecords = updatedRecordIDs.size !== 0;
     this._subscriptions.forEach(function (subscription) {
-      var owner = _this3._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation);
+      var owner = _this4._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation);
+      if (owner != null) {
+        updatedOwners.push(owner);
+      }
+    });
+  };
+  _proto.updateStaleSubscriptions = function updateStaleSubscriptions(source, updatedRecordIDs, updatedOwners, sourceOperation) {
+    var _this5 = this;
+    var hasUpdatedRecords = updatedRecordIDs.size !== 0;
+    this._staleSubscriptions.forEach(function (subscription) {
+      var owner = _this5._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation);
       if (owner != null) {
         updatedOwners.push(owner);
       }
@@ -101,6 +122,9 @@ var RelayStoreSubscriptions = /*#__PURE__*/function () {
     }
     subscription.snapshot = nextSnapshot;
     subscription.stale = false;
+    if (RelayFeatureFlags.OPTIMIZE_NOTIFY && stale) {
+      this._staleSubscriptions["delete"](subscription);
+    }
     if (nextSnapshot.data !== snapshot.data) {
       if (this.__log && RelayFeatureFlags.ENABLE_NOTIFY_SUBSCRIPTION) {
         this.__log({

package/lib/util/RelayFeatureFlags.js

@@ -27,6 +27,7 @@ var RelayFeatureFlags = {
   ENABLE_TYPENAME_PREFIXED_DATA_ID: false,
   ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false,
   CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: false,
-  FILTER_OUT_RELAY_RESOLVER_RECORDS: false
+  FILTER_OUT_RELAY_RESOLVER_RECORDS: false,
+  OPTIMIZE_NOTIFY: false
 };
 module.exports = RelayFeatureFlags;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "0.0.0-main-1ac62c2b",
+  "version": "0.0.0-main-c9cf5515",
   "keywords": [
     "graphql",
     "relay"

package/store/OperationExecutor.js.flow

@@ -515,12 +515,32 @@ class Executor<TMutation: MutationParameters> {
 
     if (responsesWithData.length === 0) {
       // no results with data, nothing to process
-      // this can occur with extensions-only payloads
+      // this can occur with extensions-only payloads, or exec time resolver
+      // responses
       const isFinal = responses.some(x => x.extensions?.is_final === true);
       if (isFinal) {
-        this._state = 'loading_final';
-        this._updateActiveState();
-        this._incrementalPayloadsPending = false;
+        if (
+          this._useExecTimeResolvers &&
+          this._state !== 'loading_final' &&
+          responses.some(x => x.extensions?.is_normalized === true)
+        ) {
+          // An exec time resolver query can flush an empty response, if the
+          // same response has been included in other queries. Check if we need
+          // to mark the request as final
+          this._execTimeResolverResponseComplete = true;
+          // Need to update the active state to mark the query as inactive,
+          // incase server payloads have completed
+          if (this._isClientQuery) {
+            // If it is a client query, there is no server response to set the
+            // final state, so we need to set it here
+            this._state = 'loading_final';
+          }
+          this._updateActiveState();
+        } else {
+          this._state = 'loading_final';
+          this._updateActiveState();
+          this._incrementalPayloadsPending = false;
+        }
       }
       this._sink.next(response);
       return;

package/store/RelayModernStore.js.flow

@@ -40,6 +40,7 @@ const {
   assertInternalActorIdentifier,
 } = require('../multi-actor-environment/ActorIdentifier');
 const deepFreeze = require('../util/deepFreeze');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
 const resolveImmediate = require('../util/resolveImmediate');
 const DataChecker = require('./DataChecker');
 const defaultGetDataID = require('./defaultGetDataID');
@@ -413,34 +414,73 @@ class RelayModernStore implements Store {
       });
     }
 
-    // Increment the current write when notifying after executing
-    // a set of changes to the store.
-    this._currentWriteEpoch++;
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+      // Increment the current write when notifying after executing
+      // a set of changes to the store.
+      this._currentWriteEpoch++;
 
-    if (invalidateStore === true) {
-      this._globalInvalidationEpoch = this._currentWriteEpoch;
+      if (invalidateStore === true) {
+        this._globalInvalidationEpoch = this._currentWriteEpoch;
+      }
     }
 
     // When a record is updated, we need to also handle records that depend on it,
     // specifically Relay Resolver result records containing results based on the
     // updated records. This both adds to updatedRecordIDs and invalidates any
     // cached data as needed.
-    this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY || this._updatedRecordIDs.size > 0) {
+      this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
+    }
 
     const source = this.getSource();
     const updatedOwners: Array<RequestDescriptor> = [];
-    this._storeSubscriptions.updateSubscriptions(
-      source,
-      this._updatedRecordIDs,
-      updatedOwners,
-      sourceOperation,
-    );
-    this._invalidationSubscriptions.forEach(subscription => {
-      this._updateInvalidationSubscription(
-        subscription,
-        invalidateStore === true,
+    if (!RelayFeatureFlags.OPTIMIZE_NOTIFY || this._updatedRecordIDs.size > 0) {
+      this._storeSubscriptions.updateSubscriptions(
+        source,
+        this._updatedRecordIDs,
+        updatedOwners,
+        sourceOperation,
       );
-    });
+    } else {
+      // If no record is updated, we still need to traverse stale subscriptions for
+      // subscriptions that were using values from optimistic updates
+      this._storeSubscriptions.updateStaleSubscriptions(
+        source,
+        this._updatedRecordIDs,
+        updatedOwners,
+        sourceOperation,
+      );
+    }
+
+    if (
+      RelayFeatureFlags.OPTIMIZE_NOTIFY &&
+      (this._updatedRecordIDs.size > 0 ||
+        updatedOwners.length > 0 ||
+        this._invalidatedRecordIDs.size > 0 ||
+        invalidateStore === true ||
+        this._globalInvalidationEpoch === this._currentWriteEpoch)
+    ) {
+      // Increment the current write when notifying after executing
+      // a set of changes to the store.
+      this._currentWriteEpoch++;
+
+      if (invalidateStore === true) {
+        this._globalInvalidationEpoch = this._currentWriteEpoch;
+      }
+    }
+
+    if (
+      !RelayFeatureFlags.OPTIMIZE_NOTIFY ||
+      this._invalidatedRecordIDs.size > 0 ||
+      invalidateStore === true
+    ) {
+      this._invalidationSubscriptions.forEach(subscription => {
+        this._updateInvalidationSubscription(
+          subscription,
+          invalidateStore === true,
+        );
+      });
+    }
 
     // If a source operation was provided (indicating the operation
     // that produced this update to the store), record the current epoch

package/store/RelayStoreSubscriptions.js.flow

@@ -43,6 +43,9 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
   __log: ?LogFunction;
   _resolverCache: ResolverCache;
   _resolverContext: ?ResolverContext;
+  // Stores `subscriptions` with stale snapshots, used for reducing the traversal
+  // that has to happen on `notify`
+  _staleSubscriptions: Set<Subscription>;
 
   constructor(
     log?: ?LogFunction,
@@ -50,6 +53,7 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     resolverContext?: ResolverContext,
   ) {
     this._subscriptions = new Set();
+    this._staleSubscriptions = new Set();
     this.__log = log;
     this._resolverCache = resolverCache;
     this._resolverContext = resolverContext;
@@ -67,6 +71,9 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     };
     const dispose = () => {
       this._subscriptions.delete(subscription);
+      if (RelayFeatureFlags.OPTIMIZE_NOTIFY && subscription.stale) {
+        this._staleSubscriptions.delete(subscription);
+      }
     };
     this._subscriptions.add(subscription);
     return {dispose};
@@ -112,6 +119,9 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
           // This subscription's data changed in the optimistic state. We will
           // need to re-read.
           subscription.stale = true;
+          if (RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+            this._staleSubscriptions.add(subscription);
+          }
         }
         subscription.snapshot = {
           data: subscription.snapshot.data,
@@ -126,6 +136,9 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
         // This subscription was created during the optimisitic state. We should
         // re-read.
         subscription.stale = true;
+        if (RelayFeatureFlags.OPTIMIZE_NOTIFY) {
+          this._staleSubscriptions.add(subscription);
+        }
       }
     });
   }
@@ -151,6 +164,27 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     });
   }
 
+  updateStaleSubscriptions(
+    source: RecordSource,
+    updatedRecordIDs: DataIDSet,
+    updatedOwners: Array<RequestDescriptor>,
+    sourceOperation?: OperationDescriptor,
+  ) {
+    const hasUpdatedRecords = updatedRecordIDs.size !== 0;
+    this._staleSubscriptions.forEach(subscription => {
+      const owner = this._updateSubscription(
+        source,
+        subscription,
+        updatedRecordIDs,
+        hasUpdatedRecords,
+        sourceOperation,
+      );
+      if (owner != null) {
+        updatedOwners.push(owner);
+      }
+    });
+  }
+
   /**
    * Notifies the callback for the subscription if the data for the associated
    * snapshot has changed.
@@ -197,6 +231,9 @@ class RelayStoreSubscriptions implements StoreSubscriptions {
     }
     subscription.snapshot = nextSnapshot;
     subscription.stale = false;
+    if (RelayFeatureFlags.OPTIMIZE_NOTIFY && stale) {
+      this._staleSubscriptions.delete(subscription);
+    }
     if (nextSnapshot.data !== snapshot.data) {
       if (this.__log && RelayFeatureFlags.ENABLE_NOTIFY_SUBSCRIPTION) {
         this.__log({

package/store/RelayStoreTypes.js.flow

@@ -422,6 +422,16 @@ export interface StoreSubscriptions {
     sourceOperation?: OperationDescriptor,
   ): void;
 
+  /**
+   * Same as `updateSubscriptions`, except it only notifies subscriptions with stale snapshots.
+   */
+  updateStaleSubscriptions(
+    source: RecordSource,
+    updatedRecordIDs: DataIDSet,
+    updatedOwners: Array<RequestDescriptor>,
+    sourceOperation?: OperationDescriptor,
+  ): void;
+
   /**
    * returns the number of subscriptions
    */

package/util/RelayFeatureFlags.js.flow

@@ -84,6 +84,9 @@ export type FeatureFlags = {
   // When enabled, records created for Relay Resolvers will be filtered out
   // from the store when serializing to JSON.
   FILTER_OUT_RELAY_RESOLVER_RECORDS: boolean,
+
+  // Reduce the work on store.notify
+  OPTIMIZE_NOTIFY: boolean,
 };
 
 const RelayFeatureFlags: FeatureFlags = {
@@ -114,6 +117,7 @@ const RelayFeatureFlags: FeatureFlags = {
   ENABLE_UI_CONTEXT_ON_RELAY_LOGGER: false,
   CHECK_ALL_FRAGMENTS_FOR_MISSING_CLIENT_EDGES: false,
   FILTER_OUT_RELAY_RESOLVER_RECORDS: false,
+  OPTIMIZE_NOTIFY: false,
 };
 
 module.exports = RelayFeatureFlags;