react-relay 15.0.0 → 16.1.0

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

@@ -1,290 +0,0 @@
-/**
- * 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.
- *
- * 
- * @format
- * @oncall relay
- */
-
-'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'),
-  fetchQueryInternal = _require2.__internal.fetchQuery,
-  RelayFeatureFlags = _require2.RelayFeatureFlags;
-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;

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

@@ -1,49 +0,0 @@
-/**
- * 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.
- *
- * 
- * @format
- * @oncall relay
- */
-
-'use strict';
-
-var _require = require('../loadQuery'),
-  useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
-var useMemoOperationDescriptor = require('../useMemoOperationDescriptor');
-var useRelayEnvironment = require('../useRelayEnvironment');
-var getQueryResultOrFetchQuery = require('./getQueryResultOrFetchQuery_REACT_CACHE');
-var useFragmentInternal = require('./useFragmentInternal_REACT_CACHE');
-var _require2 = require('react'),
-  useEffect = _require2.useEffect;
-function useLazyLoadQuery_REACT_CACHE(gqlQuery, variables, options) {
-  var _options$networkCache;
-  useTrackLoadQueryInRender();
-  var environment = useRelayEnvironment();
-  var queryOperationDescriptor = useMemoOperationDescriptor(gqlQuery, variables, (_options$networkCache = options === null || options === void 0 ? void 0 : options.networkCacheConfig) !== null && _options$networkCache !== void 0 ? _options$networkCache : {
-    force: true
-  });
-
-  // Get the query going if needed -- this may suspend.
-  var _getQueryResultOrFetc = getQueryResultOrFetchQuery(environment, queryOperationDescriptor, {
-      fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
-      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy,
-      fetchKey: options === null || options === void 0 ? void 0 : options.fetchKey
-    }),
-    queryResult = _getQueryResultOrFetc[0],
-    effect = _getQueryResultOrFetc[1];
-  useEffect(effect);
-
-  // Read the query's root fragment -- this may suspend.
-  var fragmentNode = queryResult.fragmentNode,
-    fragmentRef = queryResult.fragmentRef;
-  // $FlowExpectedError[incompatible-return] Is this a fixable incompatible-return?
-  return useFragmentInternal(fragmentNode, fragmentRef, 'useLazyLoadQuery()', {
-    fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
-    networkCacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig
-  });
-}
-module.exports = useLazyLoadQuery_REACT_CACHE;

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

@@ -1,110 +0,0 @@
-/**
- * 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.
- *
- * 
- * @format
- * @oncall relay
- */
-
-'use strict';
-
-var _require = require('../loadQuery'),
-  useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
-var useMemoOperationDescriptor = require('../useMemoOperationDescriptor');
-var useRelayEnvironment = require('../useRelayEnvironment');
-var getQueryResultOrFetchQuery = require('./getQueryResultOrFetchQuery_REACT_CACHE');
-var useFragmentInternal = require('./useFragmentInternal_REACT_CACHE');
-var invariant = require('invariant');
-var _require2 = require('react'),
-  useDebugValue = _require2.useDebugValue,
-  useEffect = _require2.useEffect;
-var _require3 = require('relay-runtime'),
-  _require3$__internal = _require3.__internal,
-  fetchQueryDeduped = _require3$__internal.fetchQueryDeduped,
-  fetchQuery = _require3$__internal.fetchQuery;
-var warning = require("fbjs/lib/warning");
-function usePreloadedQuery_REACT_CACHE(gqlQuery, preloadedQuery, options) {
-  var environment = useRelayEnvironment();
-  useTrackLoadQueryInRender();
-  var fetchKey = preloadedQuery.fetchKey,
-    fetchPolicy = preloadedQuery.fetchPolicy,
-    source = preloadedQuery.source,
-    variables = preloadedQuery.variables,
-    networkCacheConfig = preloadedQuery.networkCacheConfig;
-  var operation = useMemoOperationDescriptor(gqlQuery, variables, networkCacheConfig);
-  var fetchObservable;
-  if (preloadedQuery.kind === 'PreloadedQuery_DEPRECATED') {
-    !(operation.request.node.params.name === preloadedQuery.name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'usePreloadedQuery(): Expected data to be prefetched for query `%s`, ' + 'got prefetch results for query `%s`.', operation.request.node.params.name, preloadedQuery.name) : invariant(false) : void 0;
-    fetchObservable = fetchQueryDeduped(environment, operation.request.identifier, function () {
-      if (environment === preloadedQuery.environment && source != null) {
-        return environment.executeWithSource({
-          operation: operation,
-          source: source
-        });
-      } else {
-        return environment.execute({
-          operation: operation
-        });
-      }
-    });
-  } else {
-    process.env.NODE_ENV !== "production" ? warning(preloadedQuery.isDisposed === false, 'usePreloadedQuery(): Expected preloadedQuery to not be disposed yet. ' + 'This is because disposing the query marks it for future garbage ' + 'collection, and as such query results may no longer be present in the Relay ' + 'store. In the future, this will become a hard error.') : void 0;
-    var fallbackFetchObservable = fetchQuery(environment, operation);
-    if (source != null && environment === preloadedQuery.environment) {
-      // If the source observable exists and the environments match, reuse
-      // the source observable.
-      // If the source observable happens to be empty, we need to fall back
-      // and re-execute and de-dupe the query (at render time).
-      fetchObservable = source.ifEmpty(fallbackFetchObservable);
-    } else if (environment !== preloadedQuery.environment) {
-      // If a call to loadQuery is made with a particular environment, and that
-      // preloaded query is passed to usePreloadedQuery in a different environment
-      // context, we cannot re-use the existing preloaded query.
-      // Instead, we need to fall back and re-execute and de-dupe the query with
-      // the new environment (at render time).
-      // TODO T68036756 track occurences of this warning and turn it into a hard error
-      process.env.NODE_ENV !== "production" ? warning(false, 'usePreloadedQuery(): usePreloadedQuery was passed a preloaded query ' + 'that was created with a different environment than the one that is currently ' + 'in context. In the future, this will become a hard error.') : void 0;
-      fetchObservable = fallbackFetchObservable;
-    } else {
-      // if (source == null)
-      // If the source observable does not exist, we need to
-      // fall back and re-execute and de-dupe the query (at render time).
-      fetchObservable = fallbackFetchObservable;
-    }
-  }
-
-  // Get the query going if needed -- this may suspend.
-  var _getQueryResultOrFetc = getQueryResultOrFetchQuery(environment, operation, {
-      fetchPolicy: fetchPolicy,
-      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy,
-      fetchKey: fetchKey,
-      fetchObservable: fetchObservable
-    }),
-    queryResult = _getQueryResultOrFetc[0],
-    effect = _getQueryResultOrFetc[1];
-  useEffect(effect);
-
-  // Read the query's root fragment -- this may suspend.
-  var fragmentNode = queryResult.fragmentNode,
-    fragmentRef = queryResult.fragmentRef;
-  var data = useFragmentInternal(fragmentNode, fragmentRef, 'usePreloadedQuery()', {
-    fetchPolicy: fetchPolicy,
-    networkCacheConfig: networkCacheConfig
-  });
-  if (process.env.NODE_ENV !== "production") {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    useDebugValue({
-      query: preloadedQuery.name,
-      variables: preloadedQuery.variables,
-      data: data,
-      fetchKey: fetchKey,
-      fetchPolicy: fetchPolicy,
-      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy
-    });
-  }
-  return data;
-}
-module.exports = usePreloadedQuery_REACT_CACHE;

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

@@ -1,40 +0,0 @@
-/**
- * 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.
- *
- * @flow strict-local
- * @format
- * @oncall relay
- */
-
-'use strict';
-
-const invariant = require('invariant');
-// $FlowFixMe[prop-missing] These exist in experimental builds but aren't in React's types yet.
-const {unstable_getCacheForType, unstable_getCacheSignal} = require('react');
-const {RelayFeatureFlags} = require('relay-runtime');
-
-function getCacheForType<T>(factory: () => T): T {
-  invariant(
-    typeof unstable_getCacheForType === 'function' &&
-      RelayFeatureFlags.USE_REACT_CACHE,
-    '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.',
-  );
-  return unstable_getCacheForType(factory);
-}
-
-function getCacheSignal(): AbortSignal {
-  invariant(
-    typeof unstable_getCacheSignal === 'function' &&
-      RelayFeatureFlags.USE_REACT_CACHE,
-    '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.',
-  );
-  return unstable_getCacheSignal();
-}
-
-module.exports = {
-  getCacheForType,
-  getCacheSignal,
-};