react-relay 13.1.1 → 14.1.0

package/lib/relay-hooks/QueryResource.js

@@ -8,10 +8,9 @@
  * @emails oncall+relay
  * @format
  */
-// flowlint ambiguous-object-type:error
 'use strict';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
@@ -24,7 +23,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 +64,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 +94,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 +114,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 +265,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 +366,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/RelayEnvironmentProvider.js

@@ -8,7 +8,6 @@
  * 
  * @format
  */
-// flowlint ambiguous-object-type:error
 'use strict';
 
 var React = require('react');

package/lib/relay-hooks/SuspenseResource.js

@@ -8,10 +8,9 @@
  * @emails oncall+relay
  * @format
  */
-// flowlint ambiguous-object-type:error
 'use strict';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 

package/lib/relay-hooks/loadQuery.js

@@ -10,7 +10,7 @@
  */
 'use strict';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 

package/lib/relay-hooks/preloadQuery_DEPRECATED.js

@@ -8,10 +8,9 @@
  * 
  * @format
  */
-// flowlint ambiguous-object-type:error
 'use strict';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
@@ -64,17 +63,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/prepareEntryPoint_DEPRECATED.js

@@ -8,7 +8,6 @@
  * 
  * @format
  */
-// flowlint ambiguous-object-type:error
 'use strict';
 
 var preloadQuery = require('./preloadQuery_DEPRECATED');

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

@@ -0,0 +1,36 @@
+/**
+ * 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 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
+};

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

@@ -0,0 +1,344 @@
+/**
+ * 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 SuspenseResource = require('../SuspenseResource');
+
+var _require = require('./RelayReactCache'),
+    getCacheForType = _require.getCacheForType,
+    getCacheSignal = _require.getCacheSignal;
+
+var invariant = require('invariant');
+
+var _require2 = require('relay-runtime'),
+    RelayFeatureFlags = _require2.RelayFeatureFlags,
+    fetchQueryInternal = _require2.__internal.fetchQuery;
+
+var warning = require("fbjs/lib/warning");
+
+var DEFAULT_FETCH_POLICY = 'store-or-network';
+var WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
+
+var QueryCache = /*#__PURE__*/function () {
+  function QueryCache() {
+    this._map = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
+  }
+
+  var _proto = QueryCache.prototype;
+
+  _proto.get = function get(environment, key) {
+    var forEnv = this._map.get(environment);
+
+    if (!forEnv) {
+      forEnv = new Map();
+
+      this._map.set(environment, forEnv);
+    }
+
+    return forEnv.get(key);
+  };
+
+  _proto.set = function set(environment, key, value) {
+    var forEnv = this._map.get(environment);
+
+    if (!forEnv) {
+      forEnv = new Map();
+
+      this._map.set(environment, forEnv);
+    }
+
+    forEnv.set(key, value);
+  };
+
+  _proto["delete"] = function _delete(environment, key) {
+    var forEnv = this._map.get(environment);
+
+    if (!forEnv) {
+      return;
+    }
+
+    forEnv["delete"](key);
+
+    if (forEnv.size === 0) {
+      this._map["delete"](environment);
+    }
+  };
+
+  return QueryCache;
+}();
+
+function createQueryCache() {
+  return new QueryCache();
+}
+
+var noopOnCommit = function noopOnCommit() {
+  return function () {
+    return undefined;
+  };
+};
+
+var noopPromise = new Promise(function () {});
+
+function getQueryCacheKey(operation, fetchPolicy, renderPolicy, fetchKey) {
+  return "".concat(fetchPolicy, "-").concat(renderPolicy, "-").concat(operation.request.identifier, "-").concat(fetchKey !== null && fetchKey !== void 0 ? fetchKey : '');
+}
+
+function constructQueryResult(operation) {
+  var rootFragmentRef = {
+    __id: operation.fragment.dataID,
+    __fragments: (0, _defineProperty2["default"])({}, operation.fragment.node.name, operation.request.variables),
+    __fragmentOwner: operation.request
+  };
+  return {
+    fragmentNode: operation.request.node.fragment,
+    fragmentRef: rootFragmentRef
+  };
+}
+
+function makeInitialCacheEntry() {
+  return {
+    status: 'pending',
+    promise: noopPromise,
+    onCommit: noopOnCommit,
+    suspenseResource: null
+  };
+}
+
+function getQueryResultOrFetchQuery_REACT_CACHE(environment, queryOperationDescriptor, options) {
+  var _options$fetchPolicy, _options$renderPolicy;
+
+  var fetchPolicy = (_options$fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _options$fetchPolicy !== void 0 ? _options$fetchPolicy : DEFAULT_FETCH_POLICY;
+  var renderPolicy = (_options$renderPolicy = options === null || options === void 0 ? void 0 : options.renderPolicy) !== null && _options$renderPolicy !== void 0 ? _options$renderPolicy : environment.UNSTABLE_getDefaultRenderPolicy();
+  var cache = getCacheForType(createQueryCache);
+  var cacheKey = getQueryCacheKey(queryOperationDescriptor, fetchPolicy, renderPolicy, options === null || options === void 0 ? void 0 : options.fetchKey);
+  var initialEntry = cache.get(environment, cacheKey);
+
+  function updateCache(updater) {
+    var currentEntry = cache.get(environment, cacheKey);
+
+    if (!currentEntry) {
+      currentEntry = makeInitialCacheEntry();
+      cache.set(environment, cacheKey, currentEntry);
+    } // $FlowExpectedError[prop-missing] Extra properties are passed in -- this is fine
+
+
+    var newStatus = updater(currentEntry); // $FlowExpectedError[cannot-spread-inexact] Flow cannot understand that this is valid...
+
+    cache.set(environment, cacheKey, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, currentEntry), newStatus)); // ... but we can because QueryCacheEntry spreads QueryCacheEntryStatus, so spreading
+    // a QueryCacheEntryStatus into a QueryCacheEntry will result in a valid QueryCacheEntry.
+  } // Initiate a query to fetch the data if needed:
+
+
+  if (RelayFeatureFlags.USE_REACT_CACHE_LEGACY_TIMEOUTS) {
+    var _entry;
+
+    if (initialEntry === undefined) {
+      onCacheMiss(environment, queryOperationDescriptor, fetchPolicy, renderPolicy, updateCache, options === null || options === void 0 ? void 0 : options.fetchObservable);
+      var createdEntry = cache.get(environment, cacheKey);
+      !(createdEntry !== undefined) ? process.env.NODE_ENV !== "production" ? invariant(false, 'An entry should have been created by onCacheMiss. This is a bug in Relay.') : invariant(false) : void 0;
+      _entry = createdEntry;
+    } else {
+      _entry = initialEntry;
+    }
+
+    if (!_entry.suspenseResource) {
+      _entry.suspenseResource = new SuspenseResource(function () {
+        var retention = environment.retain(queryOperationDescriptor);
+        return {
+          dispose: function dispose() {
+            retention.dispose();
+            cache["delete"](environment, cacheKey);
+          }
+        };
+      });
+    }
+
+    if (_entry.onCommit === noopOnCommit) {
+      _entry.onCommit = function () {
+        !_entry.suspenseResource ? process.env.NODE_ENV !== "production" ? invariant(false, 'SuspenseResource should have been initialized. This is a bug in Relay.') : invariant(false) : void 0;
+
+        var retention = _entry.suspenseResource.permanentRetain(environment);
+
+        return function () {
+          retention.dispose();
+        };
+      };
+    }
+
+    _entry.suspenseResource.temporaryRetain(environment);
+  } else {
+    if (initialEntry === undefined) {
+      // This is the behavior we eventually want: We retain the query until the
+      // presiding Cache component unmounts, at which point the AbortSignal
+      // will be triggered.
+      onCacheMiss(environment, queryOperationDescriptor, fetchPolicy, renderPolicy, updateCache, options === null || options === void 0 ? void 0 : options.fetchObservable); // Since this is the first time rendering, retain the query. React will
+      // trigger the abort signal when this cache entry is no longer needed.
+
+      var retention = environment.retain(queryOperationDescriptor);
+
+      var dispose = function dispose() {
+        retention.dispose();
+        cache["delete"](environment, cacheKey);
+      };
+
+      var abortSignal = getCacheSignal();
+      abortSignal.addEventListener('abort', dispose, {
+        once: true
+      });
+    }
+  }
+
+  var entry = cache.get(environment, cacheKey); // could be a different entry now if synchronously resolved
+
+  !(entry !== undefined) ? process.env.NODE_ENV !== "production" ? invariant(false, 'An entry should have been created by onCacheMiss. This is a bug in Relay.') : invariant(false) : void 0;
+
+  switch (entry.status) {
+    case 'pending':
+      throw entry.promise;
+
+    case 'rejected':
+      throw entry.error;
+
+    case 'resolved':
+      return [entry.result, entry.onCommit];
+  }
+
+  !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'switch statement should be exhaustive') : invariant(false) : void 0;
+}
+
+function onCacheMiss(environment, operation, fetchPolicy, renderPolicy, updateCache, customFetchObservable) {
+  // NB: Besides checking if the data is available, calling `check` will write missing
+  // data to the store using any missing data handlers specified in the environment.
+  var queryAvailability = environment.check(operation);
+  var queryStatus = queryAvailability.status;
+  var hasFullQuery = queryStatus === 'available';
+  var canPartialRender = hasFullQuery || renderPolicy === 'partial' && queryStatus !== 'stale';
+  var shouldFetch;
+  var shouldRenderNow;
+
+  switch (fetchPolicy) {
+    case 'store-only':
+      {
+        shouldFetch = false;
+        shouldRenderNow = true;
+        break;
+      }
+
+    case 'store-or-network':
+      {
+        shouldFetch = !hasFullQuery;
+        shouldRenderNow = canPartialRender;
+        break;
+      }
+
+    case 'store-and-network':
+      {
+        shouldFetch = true;
+        shouldRenderNow = canPartialRender;
+        break;
+      }
+
+    case 'network-only':
+    default:
+      {
+        shouldFetch = true;
+        shouldRenderNow = false;
+        break;
+      }
+  }
+
+  if (shouldFetch) {
+    executeOperationAndKeepUpToDate(environment, operation, updateCache, customFetchObservable);
+    updateCache(function (existing) {
+      switch (existing.status) {
+        case 'resolved':
+          return existing;
+
+        case 'rejected':
+          return existing;
+
+        case 'pending':
+          return shouldRenderNow ? {
+            status: 'resolved',
+            result: constructQueryResult(operation)
+          } : existing;
+      }
+    });
+  } else {
+    !shouldRenderNow ? process.env.NODE_ENV !== "production" ? invariant(false, 'Should either fetch or be willing to render. This is a bug in Relay.') : invariant(false) : void 0;
+    updateCache(function (_existing) {
+      return {
+        status: 'resolved',
+        result: constructQueryResult(operation)
+      };
+    });
+  }
+}
+
+function executeOperationAndKeepUpToDate(environment, operation, updateCache, customFetchObservable) {
+  var resolvePromise;
+  var promise = new Promise(function (r) {
+    resolvePromise = r;
+  }); // $FlowExpectedError[prop-missing] Expando to annotate Promises.
+
+  promise.displayName = 'Relay(' + operation.request.node.operation.name + ')';
+  var isFirstPayload = true; // FIXME We may still need to cancel network requests for live queries.
+
+  var fetchObservable = customFetchObservable !== null && customFetchObservable !== void 0 ? customFetchObservable : fetchQueryInternal(environment, operation);
+  fetchObservable.subscribe({
+    start: function start(subscription) {},
+    error: function error(_error) {
+      if (isFirstPayload) {
+        updateCache(function (_existing) {
+          return {
+            status: 'rejected',
+            error: _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, 'getQueryResultOrFetchQuery: An incremental payload for query `%` returned an error: `%`:`%`.', operation.request.node.operation.name, _error.message, _error.stack) : void 0;
+      }
+
+      resolvePromise();
+      isFirstPayload = false;
+    },
+    next: function next(response) {
+      // Stop suspending on the first payload because of streaming, defer, etc.
+      updateCache(function (_existing) {
+        return {
+          status: 'resolved',
+          result: constructQueryResult(operation)
+        };
+      });
+      resolvePromise();
+      isFirstPayload = false;
+    }
+  }); // If the above subscription yields a value synchronously, then one of the updates
+  // above will have already happened and we'll now be in a resolved or rejected state.
+  // But in the usual case, we save the promise to the entry here:
+
+  updateCache(function (existing) {
+    return existing.status === 'pending' ? {
+      status: 'pending',
+      promise: promise
+    } : existing;
+  });
+}
+
+module.exports = getQueryResultOrFetchQuery_REACT_CACHE;