react-relay 13.1.1 → 14.1.0

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

@@ -0,0 +1,55 @@
+/**
+ * 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 _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/usePaginationFragment_REACT_CACHE.js

@@ -0,0 +1,150 @@
+/**
+ * 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 useLoadMoreFunction = require('../useLoadMoreFunction');
+
+var useStaticFragmentNodeWarning = require('../useStaticFragmentNodeWarning');
+
+var useRefetchableFragmentInternal = require('./useRefetchableFragmentInternal_REACT_CACHE');
+
+var _require = require('react'),
+    useCallback = _require.useCallback,
+    useDebugValue = _require.useDebugValue,
+    useState = _require.useState;
+
+var _require2 = require('relay-runtime'),
+    getFragment = _require2.getFragment,
+    getFragmentIdentifier = _require2.getFragmentIdentifier,
+    getPaginationMetadata = _require2.getPaginationMetadata;
+
+function usePaginationFragment(fragmentInput, parentFragmentRef) {
+  var fragmentNode = getFragment(fragmentInput);
+  useStaticFragmentNodeWarning(fragmentNode, 'first argument of usePaginationFragment()');
+  var componentDisplayName = 'usePaginationFragment()';
+
+  var _getPaginationMetadat = getPaginationMetadata(fragmentNode, componentDisplayName),
+      connectionPathInFragmentData = _getPaginationMetadat.connectionPathInFragmentData,
+      paginationRequest = _getPaginationMetadat.paginationRequest,
+      paginationMetadata = _getPaginationMetadat.paginationMetadata,
+      identifierField = _getPaginationMetadat.identifierField;
+
+  var _useRefetchableFragme = useRefetchableFragmentInternal(fragmentNode, parentFragmentRef, componentDisplayName),
+      fragmentData = _useRefetchableFragme.fragmentData,
+      fragmentRef = _useRefetchableFragme.fragmentRef,
+      refetch = _useRefetchableFragme.refetch;
+
+  var fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef); // Backward pagination
+
+  var _useLoadMore = useLoadMore({
+    componentDisplayName: componentDisplayName,
+    connectionPathInFragmentData: connectionPathInFragmentData,
+    direction: 'backward',
+    fragmentData: fragmentData,
+    fragmentIdentifier: fragmentIdentifier,
+    fragmentNode: fragmentNode,
+    fragmentRef: fragmentRef,
+    identifierField: identifierField,
+    paginationMetadata: paginationMetadata,
+    paginationRequest: paginationRequest
+  }),
+      loadPrevious = _useLoadMore[0],
+      hasPrevious = _useLoadMore[1],
+      isLoadingPrevious = _useLoadMore[2],
+      disposeFetchPrevious = _useLoadMore[3]; // Forward pagination
+
+
+  var _useLoadMore2 = useLoadMore({
+    componentDisplayName: componentDisplayName,
+    connectionPathInFragmentData: connectionPathInFragmentData,
+    direction: 'forward',
+    fragmentData: fragmentData,
+    fragmentIdentifier: fragmentIdentifier,
+    fragmentNode: fragmentNode,
+    fragmentRef: fragmentRef,
+    identifierField: identifierField,
+    paginationMetadata: paginationMetadata,
+    paginationRequest: paginationRequest
+  }),
+      loadNext = _useLoadMore2[0],
+      hasNext = _useLoadMore2[1],
+      isLoadingNext = _useLoadMore2[2],
+      disposeFetchNext = _useLoadMore2[3];
+
+  var refetchPagination = useCallback(function (variables, options) {
+    disposeFetchNext();
+    disposeFetchPrevious();
+    return refetch(variables, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, options), {}, {
+      __environment: undefined
+    }));
+  }, [disposeFetchNext, disposeFetchPrevious, refetch]);
+
+  if (process.env.NODE_ENV !== "production") {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useDebugValue({
+      fragment: fragmentNode.name,
+      data: fragmentData,
+      hasNext: hasNext,
+      isLoadingNext: isLoadingNext,
+      hasPrevious: hasPrevious,
+      isLoadingPrevious: isLoadingPrevious
+    });
+  }
+
+  return {
+    data: fragmentData,
+    loadNext: loadNext,
+    loadPrevious: loadPrevious,
+    hasNext: hasNext,
+    hasPrevious: hasPrevious,
+    isLoadingNext: isLoadingNext,
+    isLoadingPrevious: isLoadingPrevious,
+    refetch: refetchPagination
+  };
+}
+
+function useLoadMore(args) {
+  var _useState = useState(false),
+      isLoadingMore = _useState[0],
+      setIsLoadingMore = _useState[1];
+
+  var observer = {
+    start: function start() {
+      return setIsLoadingMore(true);
+    },
+    complete: function complete() {
+      return setIsLoadingMore(false);
+    },
+    error: function error() {
+      return setIsLoadingMore(false);
+    }
+  };
+
+  var handleReset = function handleReset() {
+    return setIsLoadingMore(false);
+  };
+
+  var _useLoadMoreFunction = useLoadMoreFunction((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, args), {}, {
+    observer: observer,
+    onReset: handleReset
+  })),
+      loadMore = _useLoadMoreFunction[0],
+      hasMore = _useLoadMoreFunction[1],
+      disposeFetch = _useLoadMoreFunction[2];
+
+  return [loadMore, hasMore, isLoadingMore, disposeFetch];
+}
+
+module.exports = usePaginationFragment;

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

@@ -0,0 +1,124 @@
+/**
+ * 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 _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; // $FlowExpectedError[incompatible-return] Is this a fixable incompatible-return?
+
+  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;