react-relay 14.1.0 → 16.0.0

package/lib/relay-hooks/QueryResource.js

@@ -1,52 +1,30 @@
-/**
- * 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';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
-
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var LRUCache = require('./LRUCache');
-
 var SuspenseResource = require('./SuspenseResource');
-
 var invariant = require('invariant');
-
 var _require = require('relay-runtime'),
-    isPromise = _require.isPromise;
-
+  isPromise = _require.isPromise;
 var warning = require("fbjs/lib/warning");
-
 var CACHE_CAPACITY = 1000;
 var DEFAULT_FETCH_POLICY = 'store-or-network';
+var DEFAULT_LIVE_FETCH_POLICY = 'store-and-network';
 var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
-
 function operationIsLiveQuery(operation) {
   return operation.request.node.params.metadata.live !== undefined;
 }
-
 function getQueryCacheIdentifier(environment, operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker) {
-  var fetchPolicy = maybeFetchPolicy !== null && maybeFetchPolicy !== void 0 ? maybeFetchPolicy : DEFAULT_FETCH_POLICY;
+  var fetchPolicy = maybeFetchPolicy !== null && maybeFetchPolicy !== void 0 ? maybeFetchPolicy : operationIsLiveQuery(operation) ? DEFAULT_LIVE_FETCH_POLICY : DEFAULT_FETCH_POLICY;
   var renderPolicy = maybeRenderPolicy !== null && maybeRenderPolicy !== void 0 ? maybeRenderPolicy : environment.UNSTABLE_getDefaultRenderPolicy();
   var cacheIdentifier = "".concat(fetchPolicy, "-").concat(renderPolicy, "-").concat(operation.request.identifier);
-
   if (cacheBreaker != null) {
     return "".concat(cacheIdentifier, "-").concat(cacheBreaker);
   }
-
   return cacheIdentifier;
 }
-
 function getQueryResult(operation, cacheIdentifier) {
   var rootFragmentRef = {
     __id: operation.fragment.dataID,
@@ -60,9 +38,7 @@ function getQueryResult(operation, cacheIdentifier) {
     operation: operation
   };
 }
-
 var nextID = 200000;
-
 function createCacheEntry(cacheIdentifier, operation, operationAvailability, value, networkSubscription, onDispose) {
   var isLiveQuery = operationIsLiveQuery(operation);
   var currentValue = value;
@@ -71,13 +47,9 @@ function createCacheEntry(cacheIdentifier, operation, operationAvailability, val
     var retention = environment.retain(operation);
     return {
       dispose: function 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 && currentNetworkSubscription != null) {
           currentNetworkSubscription.unsubscribe();
         }
-
         retention.dispose();
         onDispose(cacheEntry);
       }
@@ -98,7 +70,6 @@ function createCacheEntry(cacheIdentifier, operation, operationAvailability, val
       if (isLiveQuery && currentNetworkSubscription != null) {
         currentNetworkSubscription.unsubscribe();
       }
-
       currentNetworkSubscription = subscription;
     },
     temporaryRetain: function temporaryRetain(environment) {
@@ -113,71 +84,40 @@ function createCacheEntry(cacheIdentifier, operation, operationAvailability, val
   };
   return cacheEntry;
 }
-
 var QueryResourceImpl = /*#__PURE__*/function () {
   function QueryResourceImpl(environment) {
     var _this = this;
-
     (0, _defineProperty2["default"])(this, "_clearCacheEntry", function (cacheEntry) {
       _this._cache["delete"](cacheEntry.cacheIdentifier);
     });
     this._environment = environment;
     this._cache = LRUCache.create(CACHE_CAPACITY);
   }
-
   var _proto = QueryResourceImpl.prototype;
-
   _proto.prepare = function prepare(operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, cacheBreaker, profilerContext) {
     var cacheIdentifier = getQueryCacheIdentifier(this._environment, operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker);
     return this.prepareWithIdentifier(cacheIdentifier, operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, profilerContext);
-  }
-  /**
-   * This function should be called during a Component's render function,
-   * to either read an existing cached value for the query, or fetch the query
-   * and suspend.
-   */
-  ;
-
+  };
   _proto.prepareWithIdentifier = function prepareWithIdentifier(cacheIdentifier, operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, profilerContext) {
     var environment = this._environment;
-    var fetchPolicy = maybeFetchPolicy !== null && maybeFetchPolicy !== void 0 ? maybeFetchPolicy : DEFAULT_FETCH_POLICY;
-    var renderPolicy = maybeRenderPolicy !== null && maybeRenderPolicy !== void 0 ? maybeRenderPolicy : environment.UNSTABLE_getDefaultRenderPolicy(); // 1. Check if there's a cached value for this operation, and reuse it if
-    // it's available
-
+    var fetchPolicy = maybeFetchPolicy !== null && maybeFetchPolicy !== void 0 ? maybeFetchPolicy : operationIsLiveQuery(operation) ? DEFAULT_LIVE_FETCH_POLICY : DEFAULT_FETCH_POLICY;
+    var renderPolicy = maybeRenderPolicy !== null && maybeRenderPolicy !== void 0 ? maybeRenderPolicy : environment.UNSTABLE_getDefaultRenderPolicy();
     var cacheEntry = this._cache.get(cacheIdentifier);
-
     var temporaryRetainDisposable = null;
     var entryWasCached = cacheEntry != null;
-
     if (cacheEntry == null) {
-      // 2. If a cached value isn't available, try fetching the operation.
-      // _fetchAndSaveQuery will update the cache with either a Promise or
-      // an Error to throw, or a QueryResult to return.
       cacheEntry = this._fetchAndSaveQuery(cacheIdentifier, operation, fetchObservable, fetchPolicy, renderPolicy, profilerContext, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, observer), {}, {
         unsubscribe: function unsubscribe(subscription) {
-          // 4. If the request is cancelled, make sure to dispose
-          // of the temporary retain; this will ensure that a promise
-          // doesn't remain unnecessarily cached until the temporary retain
-          // expires. Not clearing the temporary retain might cause the
-          // query to incorrectly re-suspend.
           if (temporaryRetainDisposable != null) {
             temporaryRetainDisposable.dispose();
           }
-
           var observerUnsubscribe = observer === null || observer === void 0 ? void 0 : observer.unsubscribe;
           observerUnsubscribe && observerUnsubscribe(subscription);
         }
       }));
-    } // 3. Temporarily retain here in render phase. When the component reading
-    // the operation is committed, we will transfer ownership of data retention
-    // to the component.
-    // In case the component never commits (mounts or updates) from this render,
-    // this data retention hold will auto-release itself after a timeout.
-
-
+    }
     temporaryRetainDisposable = cacheEntry.temporaryRetain(environment);
     var cachedValue = cacheEntry.getValue();
-
     if (isPromise(cachedValue)) {
       environment.__log({
         name: 'suspense.query',
@@ -187,89 +127,59 @@ var QueryResourceImpl = /*#__PURE__*/function () {
         queryAvailability: cacheEntry.operationAvailability,
         renderPolicy: renderPolicy
       });
-
       throw cachedValue;
     }
-
     if (cachedValue instanceof Error) {
       throw cachedValue;
     }
-
     return cachedValue;
-  }
-  /**
-   * This function should be called during a component's commit phase
-   * (e.g. inside useEffect), in order to retain the operation in the Relay store
-   * and transfer ownership of the operation to the component lifecycle.
-   */
-  ;
-
+  };
   _proto.retain = function retain(queryResult, profilerContext) {
     var environment = this._environment;
     var cacheIdentifier = queryResult.cacheIdentifier,
-        operation = queryResult.operation;
-
+      operation = queryResult.operation;
     var cacheEntry = this._getOrCreateCacheEntry(cacheIdentifier, operation, null, queryResult, null);
-
     var disposable = cacheEntry.permanentRetain(environment);
-
     environment.__log({
       name: 'queryresource.retain',
       profilerContext: profilerContext,
       resourceID: cacheEntry.id
     });
-
     return {
       dispose: function dispose() {
         disposable.dispose();
       }
     };
   };
-
   _proto.releaseTemporaryRetain = function releaseTemporaryRetain(queryResult) {
     var cacheEntry = this._cache.get(queryResult.cacheIdentifier);
-
     if (cacheEntry != null) {
       cacheEntry.releaseTemporaryRetain();
     }
   };
-
   _proto.TESTS_ONLY__getCacheEntry = function TESTS_ONLY__getCacheEntry(operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker) {
     var environment = this._environment;
     var cacheIdentifier = getQueryCacheIdentifier(environment, operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker);
     return this._cache.get(cacheIdentifier);
   };
-
   _proto._getOrCreateCacheEntry = function _getOrCreateCacheEntry(cacheIdentifier, operation, operationAvailability, value, networkSubscription) {
     var cacheEntry = this._cache.get(cacheIdentifier);
-
     if (cacheEntry == null) {
       cacheEntry = createCacheEntry(cacheIdentifier, operation, operationAvailability, value, networkSubscription, this._clearCacheEntry);
-
       this._cache.set(cacheIdentifier, cacheEntry);
     }
-
     return cacheEntry;
   };
-
   _proto._fetchAndSaveQuery = function _fetchAndSaveQuery(cacheIdentifier, operation, fetchObservable, fetchPolicy, renderPolicy, profilerContext, observer) {
     var _this2 = this;
-
-    var environment = this._environment; // NOTE: Running `check` will write missing data to the store using any
-    // missing data handlers specified on the environment;
-    // We run it here first to make the handlers get a chance to populate
-    // missing data.
-
+    var environment = this._environment;
     var queryAvailability = environment.check(operation);
     var queryStatus = queryAvailability.status;
     var hasFullQuery = queryStatus === 'available';
     var canPartialRender = hasFullQuery || renderPolicy === 'partial' && queryStatus !== 'stale';
     var shouldFetch;
-    var shouldAllowRender; // Different definitions for Promise in our repos can cause this variable
-    // to cause errors when synced elsewhere
-
+    var shouldAllowRender;
     var resolveNetworkPromise = function resolveNetworkPromise() {};
-
     switch (fetchPolicy) {
       case 'store-only':
         {
@@ -277,21 +187,18 @@ var QueryResourceImpl = /*#__PURE__*/function () {
           shouldAllowRender = true;
           break;
         }
-
       case 'store-or-network':
         {
           shouldFetch = !hasFullQuery;
           shouldAllowRender = canPartialRender;
           break;
         }
-
       case 'store-and-network':
         {
           shouldFetch = true;
           shouldAllowRender = canPartialRender;
           break;
         }
-
       case 'network-only':
       default:
         {
@@ -299,40 +206,26 @@ var QueryResourceImpl = /*#__PURE__*/function () {
           shouldAllowRender = false;
           break;
         }
-    } // NOTE: If this value is false, we will cache a promise for this
-    // query, which means we will suspend here at this query root.
-    // If it's true, we will cache the query resource and allow rendering to
-    // continue.
-
-
+    }
     if (shouldAllowRender) {
       var queryResult = getQueryResult(operation, cacheIdentifier);
-
       var _cacheEntry = createCacheEntry(cacheIdentifier, operation, queryAvailability, queryResult, null, this._clearCacheEntry);
-
       this._cache.set(cacheIdentifier, _cacheEntry);
     }
-
     if (shouldFetch) {
       var _queryResult = getQueryResult(operation, cacheIdentifier);
-
       var networkSubscription;
       fetchObservable.subscribe({
         start: function start(subscription) {
           networkSubscription = subscription;
-
           var cacheEntry = _this2._cache.get(cacheIdentifier);
-
           if (cacheEntry) {
             cacheEntry.setNetworkSubscription(networkSubscription);
           }
-
           var observerStart = observer === null || observer === void 0 ? void 0 : observer.start;
-
           if (observerStart) {
             var subscriptionWithConditionalCancelation = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, subscription), {}, {
               unsubscribe: function unsubscribe() {
-                // Only live queries should have their network requests canceled.
                 if (operationIsLiveQuery(operation)) {
                   subscription.unsubscribe();
                 }
@@ -343,32 +236,22 @@ var QueryResourceImpl = /*#__PURE__*/function () {
         },
         next: function next() {
           var cacheEntry = _this2._getOrCreateCacheEntry(cacheIdentifier, operation, queryAvailability, _queryResult, networkSubscription);
-
           cacheEntry.processedPayloadsCount += 1;
           cacheEntry.setValue(_queryResult);
           resolveNetworkPromise();
           var observerNext = observer === null || observer === void 0 ? void 0 : observer.next;
-
           if (observerNext != null) {
             var snapshot = environment.lookup(operation.fragment);
             observerNext(snapshot);
           }
         },
         error: function error(_error) {
-          var cacheEntry = _this2._getOrCreateCacheEntry(cacheIdentifier, operation, queryAvailability, _error, networkSubscription); // If, this is the first thing we receive for the query,
-          // before any other payload handled is error, we will cache and
-          // re-throw that error later.
-          // We will ignore errors for any incremental payloads we receive.
-
-
+          var cacheEntry = _this2._getOrCreateCacheEntry(cacheIdentifier, operation, queryAvailability, _error, networkSubscription);
           if (cacheEntry.processedPayloadsCount === 0) {
             cacheEntry.setValue(_error);
           } 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 `%s` returned an error: `%s`.', operation.fragment.node.name, String(_error.message)) : void 0;
           }
-
           resolveNetworkPromise();
           networkSubscription = null;
           cacheEntry.setNetworkSubscription(null);
@@ -378,40 +261,30 @@ var QueryResourceImpl = /*#__PURE__*/function () {
         complete: function complete() {
           resolveNetworkPromise();
           networkSubscription = null;
-
           var cacheEntry = _this2._cache.get(cacheIdentifier);
-
           if (cacheEntry) {
             cacheEntry.setNetworkSubscription(null);
           }
-
           var observerComplete = observer === null || observer === void 0 ? void 0 : observer.complete;
           observerComplete && observerComplete();
         },
         unsubscribe: observer === null || observer === void 0 ? void 0 : observer.unsubscribe
       });
-
       var _cacheEntry2 = this._cache.get(cacheIdentifier);
-
       if (!_cacheEntry2) {
         var networkPromise = new Promise(function (resolve) {
           resolveNetworkPromise = resolve;
-        }); // $FlowExpectedError[prop-missing] Expando to annotate Promises.
-
+        });
         networkPromise.displayName = 'Relay(' + operation.fragment.node.name + ')';
         _cacheEntry2 = createCacheEntry(cacheIdentifier, operation, queryAvailability, networkPromise, networkSubscription, this._clearCacheEntry);
-
         this._cache.set(cacheIdentifier, _cacheEntry2);
       }
     } else {
       var observerComplete = observer === null || observer === void 0 ? void 0 : observer.complete;
       observerComplete && observerComplete();
     }
-
     var cacheEntry = this._cache.get(cacheIdentifier);
-
     !(cacheEntry != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Relay: Expected to have cached a result when attempting to fetch query.' + "If you're seeing this, this is likely a bug in Relay.") : invariant(false) : void 0;
-
     environment.__log({
       name: 'queryresource.fetch',
       resourceID: cacheEntry.id,
@@ -422,31 +295,23 @@ var QueryResourceImpl = /*#__PURE__*/function () {
       queryAvailability: queryAvailability,
       shouldFetch: shouldFetch
     });
-
     return cacheEntry;
   };
-
   return QueryResourceImpl;
 }();
-
 function createQueryResource(environment) {
   return new QueryResourceImpl(environment);
 }
-
 var dataResources = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
-
 function getQueryResourceForEnvironment(environment) {
   var cached = dataResources.get(environment);
-
   if (cached) {
     return cached;
   }
-
   var newDataResource = createQueryResource(environment);
   dataResources.set(environment, newDataResource);
   return newDataResource;
 }
-
 module.exports = {
   createQueryResource: createQueryResource,
   getQueryResourceForEnvironment: getQueryResourceForEnvironment,

package/lib/relay-hooks/RelayEnvironmentProvider.js

@@ -1,25 +1,12 @@
-/**
- * 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';
 
+var ReactRelayContext = require('./../ReactRelayContext');
 var React = require('react');
-
-var ReactRelayContext = require('react-relay/ReactRelayContext');
-
 var useMemo = React.useMemo;
-
 function RelayEnvironmentProvider(props) {
   var children = props.children,
-      environment = props.environment,
-      getEnvironmentForActor = props.getEnvironmentForActor;
+    environment = props.environment,
+    getEnvironmentForActor = props.getEnvironmentForActor;
   var context = useMemo(function () {
     return {
       environment: environment,
@@ -30,5 +17,4 @@ function RelayEnvironmentProvider(props) {
     value: context
   }, children);
 }
-
 module.exports = RelayEnvironmentProvider;

package/lib/relay-hooks/SuspenseResource.js

@@ -1,129 +1,72 @@
-/**
- * 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';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var invariant = require('invariant');
-
 var TEMPORARY_RETAIN_DURATION_MS = 5 * 60 * 1000;
-/**
- * Allows you to retain a resource as part of a component lifecycle accounting
- * for Suspense. You temporarily retain the resource during render, then
- * permanently retain it during commit and release it during unmount.
- */
-
 var SuspenseResource = /*#__PURE__*/function () {
   function SuspenseResource(retain) {
     var _this = this;
-
     (0, _defineProperty2["default"])(this, "_retainCount", 0);
     (0, _defineProperty2["default"])(this, "_retainDisposable", null);
     (0, _defineProperty2["default"])(this, "_releaseTemporaryRetain", null);
-
     this._retain = function (environment) {
       _this._retainCount++;
-
       if (_this._retainCount === 1) {
         _this._retainDisposable = retain(environment);
       }
-
       return {
         dispose: function dispose() {
           _this._retainCount = Math.max(0, _this._retainCount - 1);
-
           if (_this._retainCount === 0) {
             !(_this._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;
-
             _this._retainDisposable.dispose();
-
             _this._retainDisposable = null;
           }
         }
       };
     };
   }
-
   var _proto = SuspenseResource.prototype;
-
   _proto.temporaryRetain = function temporaryRetain(environment) {
     var _this2 = this;
-
     var _this$_releaseTempora;
-
-    // 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() {}
       };
-    } // 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 retention = this._retain(environment);
-
     var releaseQueryTimeout = null;
-
     var releaseTemporaryRetain = function releaseTemporaryRetain() {
       clearTimeout(releaseQueryTimeout);
       releaseQueryTimeout = null;
       _this2._releaseTemporaryRetain = null;
       retention.dispose();
     };
-
-    releaseQueryTimeout = setTimeout(releaseTemporaryRetain, TEMPORARY_RETAIN_DURATION_MS); // 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.
-
+    releaseQueryTimeout = setTimeout(releaseTemporaryRetain, TEMPORARY_RETAIN_DURATION_MS);
     (_this$_releaseTempora = this._releaseTemporaryRetain) === null || _this$_releaseTempora === void 0 ? void 0 : _this$_releaseTempora.call(this);
     this._releaseTemporaryRetain = releaseTemporaryRetain;
     return {
       dispose: function dispose() {
         var _this$_releaseTempora2;
-
         (_this$_releaseTempora2 = _this2._releaseTemporaryRetain) === null || _this$_releaseTempora2 === void 0 ? void 0 : _this$_releaseTempora2.call(_this2);
       }
     };
   };
-
   _proto.permanentRetain = function permanentRetain(environment) {
     var disposable = this._retain(environment);
-
     this.releaseTemporaryRetain();
     return disposable;
   };
-
   _proto.releaseTemporaryRetain = function releaseTemporaryRetain() {
     var _this$_releaseTempora3;
-
     (_this$_releaseTempora3 = this._releaseTemporaryRetain) === null || _this$_releaseTempora3 === void 0 ? void 0 : _this$_releaseTempora3.call(this);
     this._releaseTemporaryRetain = null;
   };
-
   _proto.getRetainCount = function getRetainCount() {
     return this._retainCount;
   };
-
   return SuspenseResource;
 }();
-
 module.exports = SuspenseResource;