react-relay 13.1.0 → 14.0.0

package/lib/relay-hooks/FragmentResource.js

@@ -38,9 +38,9 @@ var _require2 = require('relay-runtime'),
     getPendingOperationsForFragment = _require2.getPendingOperationsForFragment,
     getSelector = _require2.getSelector,
     getVariablesFromFragment = _require2.getVariablesFromFragment,
+    handlePotentialSnapshotErrors = _require2.handlePotentialSnapshotErrors,
     isPromise = _require2.isPromise,
-    recycleNodesInto = _require2.recycleNodesInto,
-    reportMissingRequiredFields = _require2.reportMissingRequiredFields;
+    recycleNodesInto = _require2.recycleNodesInto;
 
 var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
 // TODO: Fix to not rely on LRU. If the number of active fragments exceeds this
@@ -74,6 +74,16 @@ function hasMissingClientEdges(snapshot) {
   return ((_snapshot$missingClie = (_snapshot$missingClie2 = snapshot.missingClientEdges) === null || _snapshot$missingClie2 === void 0 ? void 0 : _snapshot$missingClie2.length) !== null && _snapshot$missingClie !== void 0 ? _snapshot$missingClie : 0) > 0;
 }
 
+function missingLiveResolverFields(snapshot) {
+  if (Array.isArray(snapshot)) {
+    return snapshot.map(function (s) {
+      return s.missingLiveResolverFields;
+    }).filter(Boolean).flat();
+  }
+
+  return snapshot.missingLiveResolverFields;
+}
+
 function singularOrPluralForEach(snapshot, f) {
   if (Array.isArray(snapshot)) {
     snapshot.forEach(f);
@@ -210,7 +220,7 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
   _proto2.readWithIdentifier = function readWithIdentifier(fragmentNode, fragmentRef, fragmentIdentifier, componentDisplayName, fragmentKey) {
     var _this3 = this;
 
-    var _fragmentNode$metadat, _clientEdgePromises;
+    var _fragmentNode$metadat, _fragmentNode$metadat2, _missingLiveResolverF2, _missingLiveResolverF3;
 
     var environment = this._environment; // If fragmentRef is null or undefined, pass it directly through.
     // This is a convenience when consuming fragments via a HOC API, when the
@@ -248,6 +258,8 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
     var cachedValue = this._cache.get(fragmentIdentifier);
 
     if (cachedValue != null) {
+      var _missingLiveResolverF;
+
       if (cachedValue.kind === 'pending' && isPromise(cachedValue.promise)) {
         environment.__log({
           name: 'suspense.fragment',
@@ -262,8 +274,8 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
         throw cachedValue.promise;
       }
 
-      if (cachedValue.kind === 'done' && cachedValue.result.snapshot) {
-        this._reportMissingRequiredFieldsInSnapshot(cachedValue.result.snapshot);
+      if (cachedValue.kind === 'done' && cachedValue.result.snapshot && !((_missingLiveResolverF = missingLiveResolverFields(cachedValue.result.snapshot)) === null || _missingLiveResolverF === void 0 ? void 0 : _missingLiveResolverF.length)) {
+        this._handlePotentialSnapshotErrorsInSnapshot(cachedValue.result.snapshot);
 
         return cachedValue.result;
       }
@@ -279,7 +291,7 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
     var fragmentResult = getFragmentResult(fragmentIdentifier, snapshot, storeEpoch);
 
     if (!fragmentResult.isMissingData) {
-      this._reportMissingRequiredFieldsInSnapshot(snapshot);
+      this._handlePotentialSnapshotErrorsInSnapshot(snapshot);
 
       this._cache.set(fragmentIdentifier, {
         kind: 'done',
@@ -300,7 +312,7 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
 
     var clientEdgeRequests = null;
 
-    if (RelayFeatureFlags.ENABLE_CLIENT_EDGES && hasMissingClientEdges(snapshot)) {
+    if (RelayFeatureFlags.ENABLE_CLIENT_EDGES && ((_fragmentNode$metadat2 = fragmentNode.metadata) === null || _fragmentNode$metadat2 === void 0 ? void 0 : _fragmentNode$metadat2.hasClientEdges) === true && hasMissingClientEdges(snapshot)) {
       clientEdgeRequests = [];
       var queryResource = getQueryResourceForEnvironment(this._environment);
       var queryResults = [];
@@ -328,14 +340,12 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
       this._clientEdgeQueryResultsCache.recordQueryResults(fragmentIdentifier, queryResults);
     }
 
-    var clientEdgePromises = null;
+    var clientEdgePromises = [];
 
     if (RelayFeatureFlags.ENABLE_CLIENT_EDGES && clientEdgeRequests) {
       clientEdgePromises = clientEdgeRequests.map(function (request) {
         return getPromiseForActiveRequest(_this3._environment, request);
-      }).filter(function (p) {
-        return p != null;
-      });
+      }).filter(Boolean);
     } // Finally look for operations in flight for our parent query:
 
 
@@ -345,8 +355,15 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
 
     var parentQueryPromiseResultPromise = parentQueryPromiseResult === null || parentQueryPromiseResult === void 0 ? void 0 : parentQueryPromiseResult.promise; // for refinement
 
-    if (((_clientEdgePromises = clientEdgePromises) === null || _clientEdgePromises === void 0 ? void 0 : _clientEdgePromises.length) || isPromise(parentQueryPromiseResultPromise)) {
-      var _parentQueryPromiseRe, _clientEdgeRequests2, _clientEdgePromises2;
+    var missingResolverFieldPromises = (_missingLiveResolverF2 = (_missingLiveResolverF3 = missingLiveResolverFields(snapshot)) === null || _missingLiveResolverF3 === void 0 ? void 0 : _missingLiveResolverF3.map(function (_ref2) {
+      var liveStateID = _ref2.liveStateID;
+      var store = environment.getStore(); // $FlowFixMe[prop-missing] This is expected to be a LiveResolverStore
+
+      return store.getLiveResolverPromise(liveStateID);
+    })) !== null && _missingLiveResolverF2 !== void 0 ? _missingLiveResolverF2 : [];
+
+    if (clientEdgePromises.length || missingResolverFieldPromises.length || isPromise(parentQueryPromiseResultPromise)) {
+      var _parentQueryPromiseRe, _clientEdgeRequests2;
 
       environment.__log({
         name: 'suspense.fragment',
@@ -355,13 +372,37 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
         isRelayHooks: true,
         isPromiseCached: false,
         isMissingData: fragmentResult.isMissingData,
+        // TODO! Attach information here about missing live resolver fields
         pendingOperations: [].concat((0, _toConsumableArray2["default"])((_parentQueryPromiseRe = parentQueryPromiseResult === null || parentQueryPromiseResult === void 0 ? void 0 : parentQueryPromiseResult.pendingOperations) !== null && _parentQueryPromiseRe !== void 0 ? _parentQueryPromiseRe : []), (0, _toConsumableArray2["default"])((_clientEdgeRequests2 = clientEdgeRequests) !== null && _clientEdgeRequests2 !== void 0 ? _clientEdgeRequests2 : []))
       });
 
-      throw ((_clientEdgePromises2 = clientEdgePromises) === null || _clientEdgePromises2 === void 0 ? void 0 : _clientEdgePromises2.length) ? Promise.all([parentQueryPromiseResultPromise].concat((0, _toConsumableArray2["default"])(clientEdgePromises))) : parentQueryPromiseResultPromise;
+      var promises = [];
+
+      if (clientEdgePromises.length > 0) {
+        promises = promises.concat(clientEdgePromises);
+      }
+
+      if (missingResolverFieldPromises.length > 0) {
+        promises = promises.concat(missingResolverFieldPromises);
+      }
+
+      if (promises.length > 0) {
+        if (parentQueryPromiseResultPromise) {
+          promises.push(parentQueryPromiseResultPromise);
+        }
+
+        throw Promise.all(promises);
+      } // Note: we are re-throwing the `parentQueryPromiseResultPromise` here,
+      // because some of our suspense-related code is relying on the instance equality
+      // of thrown promises. See FragmentResource-test.js
+
+
+      if (parentQueryPromiseResultPromise) {
+        throw parentQueryPromiseResultPromise;
+      }
     }
 
-    this._reportMissingRequiredFieldsInSnapshot(snapshot);
+    this._handlePotentialSnapshotErrorsInSnapshot(snapshot);
 
     return getFragmentResult(fragmentIdentifier, snapshot, storeEpoch);
   };
@@ -383,19 +424,15 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
     };
   };
 
-  _proto2._reportMissingRequiredFieldsInSnapshot = function _reportMissingRequiredFieldsInSnapshot(snapshot) {
+  _proto2._handlePotentialSnapshotErrorsInSnapshot = function _handlePotentialSnapshotErrorsInSnapshot(snapshot) {
     var _this4 = this;
 
     if (Array.isArray(snapshot)) {
       snapshot.forEach(function (s) {
-        if (s.missingRequiredFields != null) {
-          reportMissingRequiredFields(_this4._environment, s.missingRequiredFields);
-        }
+        handlePotentialSnapshotErrors(_this4._environment, s.missingRequiredFields, s.relayResolverErrors);
       });
     } else {
-      if (snapshot.missingRequiredFields != null) {
-        reportMissingRequiredFields(this._environment, snapshot.missingRequiredFields);
-      }
+      handlePotentialSnapshotErrors(this._environment, snapshot.missingRequiredFields, snapshot.relayResolverErrors);
     }
   };
 
@@ -557,9 +594,11 @@ var FragmentResourceImpl = /*#__PURE__*/function () {
       data: updatedData,
       isMissingData: currentSnapshot.isMissingData,
       missingClientEdges: currentSnapshot.missingClientEdges,
+      missingLiveResolverFields: currentSnapshot.missingLiveResolverFields,
       seenRecords: currentSnapshot.seenRecords,
       selector: currentSnapshot.selector,
-      missingRequiredFields: currentSnapshot.missingRequiredFields
+      missingRequiredFields: currentSnapshot.missingRequiredFields,
+      relayResolverErrors: currentSnapshot.relayResolverErrors
     };
 
     if (updatedData !== renderData) {

package/lib/relay-hooks/HooksImplementation.js

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * 
+ * @format
+ */
+'use strict'; // flowlint ambiguous-object-type:error
+
+var warning = require("fbjs/lib/warning");
+
+var implementation = null;
+
+function inject(impl) {
+  process.env.NODE_ENV !== "production" ? warning(implementation !== null, 'Relay HooksImplementation was injected twice.') : void 0;
+  implementation = impl;
+}
+
+function get() {
+  return implementation;
+}
+
+module.exports = {
+  inject: inject,
+  get: get
+};

package/lib/relay-hooks/MatchContainer.js

@@ -137,6 +137,7 @@ function MatchContainer(_ref2) {
 
   if (LoadedContainer != null && fragmentProps != null) {
     // $FlowFixMe[incompatible-type]
+    // $FlowFixMe[cannot-spread-indexer]
     return /*#__PURE__*/React.createElement(LoadedContainer, (0, _extends2["default"])({}, props, fragmentProps));
   } else {
     return fallback !== null && fallback !== void 0 ? fallback : null;

package/lib/relay-hooks/QueryResource.js

@@ -24,7 +24,6 @@ var SuspenseResource = require('./SuspenseResource');
 var invariant = require('invariant');
 
 var _require = require('relay-runtime'),
-    RelayFeatureFlags = _require.RelayFeatureFlags,
     isPromise = _require.isPromise;
 
 var warning = require("fbjs/lib/warning");
@@ -66,18 +65,6 @@ function getQueryResult(operation, cacheIdentifier) {
 var nextID = 200000;
 
 function createCacheEntry(cacheIdentifier, operation, operationAvailability, value, networkSubscription, onDispose) {
-  // There should be no behavior difference between createCacheEntry_new and
-  // createCacheEntry_old, and it doesn't directly relate to Client Edges.
-  // It was just a refactoring that was needed for Client Edges but that
-  // is behind the feature flag just in case there is any accidental breakage.
-  if (RelayFeatureFlags.REFACTOR_SUSPENSE_RESOURCE) {
-    return createCacheEntry_new(cacheIdentifier, operation, operationAvailability, value, networkSubscription, onDispose);
-  } else {
-    return createCacheEntry_old(cacheIdentifier, operation, operationAvailability, value, networkSubscription, onDispose);
-  }
-}
-
-function createCacheEntry_new(cacheIdentifier, operation, operationAvailability, value, networkSubscription, onDispose) {
   var isLiveQuery = operationIsLiveQuery(operation);
   var currentValue = value;
   var currentNetworkSubscription = networkSubscription;
@@ -108,12 +95,6 @@ function createCacheEntry_new(cacheIdentifier, operation, operationAvailability,
     setValue: function setValue(val) {
       currentValue = val;
     },
-    getRetainCount: function getRetainCount() {
-      return suspenseResource.getRetainCount();
-    },
-    getNetworkSubscription: function getNetworkSubscription() {
-      return currentNetworkSubscription;
-    },
     setNetworkSubscription: function setNetworkSubscription(subscription) {
       if (isLiveQuery && currentNetworkSubscription != null) {
         currentNetworkSubscription.unsubscribe();
@@ -134,156 +115,12 @@ function createCacheEntry_new(cacheIdentifier, operation, operationAvailability,
   return cacheEntry;
 }
 
-var DATA_RETENTION_TIMEOUT = 5 * 60 * 1000;
-
-function createCacheEntry_old(cacheIdentifier, operation, operationAvailability, value, networkSubscription, onDispose) {
-  var isLiveQuery = operationIsLiveQuery(operation);
-  var currentValue = value;
-  var retainCount = 0;
-  var retainDisposable = null;
-  var _releaseTemporaryRetain = null;
-  var currentNetworkSubscription = networkSubscription;
-
-  var retain = function retain(environment) {
-    retainCount++;
-
-    if (retainCount === 1) {
-      retainDisposable = environment.retain(operation);
-    }
-
-    return {
-      dispose: function dispose() {
-        retainCount = Math.max(0, retainCount - 1);
-
-        if (retainCount === 0) {
-          !(retainDisposable != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Relay: Expected disposable to release query to be defined.' + "If you're seeing this, this is likely a bug in Relay.") : invariant(false) : void 0;
-          retainDisposable.dispose();
-          retainDisposable = null;
-        }
-
-        onDispose(cacheEntry);
-      }
-    };
-  };
-
-  var cacheEntry = {
-    cacheIdentifier: cacheIdentifier,
-    id: nextID++,
-    processedPayloadsCount: 0,
-    operationAvailability: operationAvailability,
-    getValue: function getValue() {
-      return currentValue;
-    },
-    setValue: function setValue(val) {
-      currentValue = val;
-    },
-    getRetainCount: function getRetainCount() {
-      return retainCount;
-    },
-    getNetworkSubscription: function getNetworkSubscription() {
-      return currentNetworkSubscription;
-    },
-    setNetworkSubscription: function setNetworkSubscription(subscription) {
-      if (isLiveQuery && currentNetworkSubscription != null) {
-        currentNetworkSubscription.unsubscribe();
-      }
-
-      currentNetworkSubscription = subscription;
-    },
-    temporaryRetain: function temporaryRetain(environment) {
-      // NOTE: If we're executing in a server environment, there's no need
-      // to create temporary retains, since the component will never commit.
-      if (environment.isServer()) {
-        return {
-          dispose: function dispose() {}
-        };
-      } // NOTE: temporaryRetain is called during the render phase. However,
-      // given that we can't tell if this render will eventually commit or not,
-      // we create a timer to autodispose of this retain in case the associated
-      // component never commits.
-      // If the component /does/ commit, permanentRetain will clear this timeout
-      // and permanently retain the data.
-
-
-      var disposable = retain(environment);
-      var releaseQueryTimeout = null;
-
-      var localReleaseTemporaryRetain = function localReleaseTemporaryRetain() {
-        clearTimeout(releaseQueryTimeout);
-        releaseQueryTimeout = null;
-        _releaseTemporaryRetain = null;
-        disposable.dispose(); // Normally if this entry never commits, the request would've ended by the
-        // time this timeout expires and the temporary retain is released. However,
-        // we need to do this for live queries which remain open indefinitely.
-
-        if (isLiveQuery && retainCount <= 0 && currentNetworkSubscription != null) {
-          currentNetworkSubscription.unsubscribe();
-        }
-      };
-
-      releaseQueryTimeout = setTimeout(localReleaseTemporaryRetain, DATA_RETENTION_TIMEOUT); // NOTE: Since temporaryRetain can be called multiple times, we release
-      // the previous temporary retain after we re-establish a new one, since
-      // we only ever need a single temporary retain until the permanent retain is
-      // established.
-      // temporaryRetain may be called multiple times by React during the render
-      // phase, as well as multiple times by other query components that are
-      // rendering the same query/variables.
-
-      if (_releaseTemporaryRetain != null) {
-        _releaseTemporaryRetain();
-      }
-
-      _releaseTemporaryRetain = localReleaseTemporaryRetain;
-      return {
-        dispose: function dispose() {
-          _releaseTemporaryRetain && _releaseTemporaryRetain();
-        }
-      };
-    },
-    permanentRetain: function permanentRetain(environment) {
-      var disposable = retain(environment);
-
-      if (_releaseTemporaryRetain != null) {
-        _releaseTemporaryRetain();
-
-        _releaseTemporaryRetain = null;
-      }
-
-      return {
-        dispose: function dispose() {
-          disposable.dispose();
-
-          if (isLiveQuery && retainCount <= 0 && currentNetworkSubscription != null) {
-            currentNetworkSubscription.unsubscribe();
-          }
-        }
-      };
-    },
-    releaseTemporaryRetain: function releaseTemporaryRetain() {
-      if (_releaseTemporaryRetain != null) {
-        _releaseTemporaryRetain();
-
-        _releaseTemporaryRetain = null;
-      }
-    }
-  };
-  return cacheEntry;
-}
-
 var QueryResourceImpl = /*#__PURE__*/function () {
   function QueryResourceImpl(environment) {
     var _this = this;
 
     (0, _defineProperty2["default"])(this, "_clearCacheEntry", function (cacheEntry) {
-      // The new code does this retainCount <= 0 check within SuspenseResource
-      // before calling _clearCacheEntry, whereas with the old code we do it here.
-      if (RelayFeatureFlags.REFACTOR_SUSPENSE_RESOURCE) {
-        _this._cache["delete"](cacheEntry.cacheIdentifier);
-      } else {
-        if (cacheEntry.getRetainCount() <= 0) {
-          _this._cache["delete"](cacheEntry.cacheIdentifier);
-        }
-      }
+      _this._cache["delete"](cacheEntry.cacheIdentifier);
     });
     this._environment = environment;
     this._cache = LRUCache.create(CACHE_CAPACITY);
@@ -429,7 +266,8 @@ var QueryResourceImpl = /*#__PURE__*/function () {
     var hasFullQuery = queryStatus === 'available';
     var canPartialRender = hasFullQuery || renderPolicy === 'partial' && queryStatus !== 'stale';
     var shouldFetch;
-    var shouldAllowRender;
+    var shouldAllowRender; // Different definitions for Promise in our repos can cause this variable
+    // to cause errors when synced elsewhere
 
     var resolveNetworkPromise = function resolveNetworkPromise() {};
 
@@ -529,7 +367,7 @@ var QueryResourceImpl = /*#__PURE__*/function () {
           } else {
             // TODO:T92030819 Remove this warning and actually throw the network error
             // To complete this task we need to have a way of precisely tracking suspendable points
-            process.env.NODE_ENV !== "production" ? warning(false, 'QueryResource: An incremental payload for query `%` returned an error: `%`:`%`.', operation.fragment.node.name, _error.message, _error.stack) : void 0;
+            process.env.NODE_ENV !== "production" ? warning(false, 'QueryResource: An incremental payload for query `%s` returned an error: `%s`.', operation.fragment.node.name, String(_error.message)) : void 0;
           }
 
           resolveNetworkPromise();

package/lib/relay-hooks/preloadQuery_DEPRECATED.js

@@ -64,17 +64,13 @@ function preloadQuery(environment, preloadableRequest, variables, options, envir
         return;
       }
 
-      if (RelayFeatureFlags.DELAY_CLEANUP_OF_PENDING_PRELOAD_QUERIES === true) {
-        setTimeout(function () {
-          // Clear the cache entry after the default timeout
-          // null-check for Flow
-          if (queryEntry != null) {
-            cleanup(pendingQueries, queryEntry);
-          }
-        }, DEFAULT_PREFETCH_TIMEOUT);
-      } else {
-        cleanup(pendingQueries, queryEntry);
-      }
+      setTimeout(function () {
+        // Clear the cache entry after the default timeout
+        // null-check for Flow
+        if (queryEntry != null) {
+          cleanup(pendingQueries, queryEntry);
+        }
+      }, DEFAULT_PREFETCH_TIMEOUT);
     };
   }) : null;
   return {

package/lib/relay-hooks/react-cache/RelayReactCache.js

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ *
+ * 
+ * @emails oncall+relay
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var invariant = require('invariant'); // $FlowFixMe[prop-missing] These exist in experimental builds but aren't in React's types yet.
+
+
+var _require = require('react'),
+    unstable_getCacheForType = _require.unstable_getCacheForType,
+    unstable_getCacheSignal = _require.unstable_getCacheSignal;
+
+var _require2 = require('relay-runtime'),
+    RelayFeatureFlags = _require2.RelayFeatureFlags;
+
+function getCacheForType(factory) {
+  !(typeof unstable_getCacheForType === 'function' && RelayFeatureFlags.USE_REACT_CACHE) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReactCache.getCacheForType should only be called when the USE_REACT_CACHE feature flag is enabled and when on an experimental React build that supports it.') : invariant(false) : void 0;
+  return unstable_getCacheForType(factory);
+}
+
+function getCacheSignal() {
+  !(typeof unstable_getCacheSignal === 'function' && RelayFeatureFlags.USE_REACT_CACHE) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReactCache.getCacheSignal should only be called when the USE_REACT_CACHE feature flag is enabled and when on an experimental React build that supports it.') : invariant(false) : void 0;
+  return unstable_getCacheSignal();
+}
+
+module.exports = {
+  getCacheForType: getCacheForType,
+  getCacheSignal: getCacheSignal
+};