react-relay 16.0.0 → 16.1.0

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

@@ -1,430 +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';
-
-import type {
-  FetchPolicy,
-  GraphQLResponse,
-  IEnvironment,
-  Observable,
-  OperationDescriptor,
-  ReaderFragment,
-  RenderPolicy,
-} from 'relay-runtime';
-
-const SuspenseResource = require('../SuspenseResource');
-const {getCacheForType, getCacheSignal} = require('./RelayReactCache');
-const invariant = require('invariant');
-const {
-  __internal: {fetchQuery: fetchQueryInternal},
-  RelayFeatureFlags,
-} = require('relay-runtime');
-const warning = require('warning');
-
-type QueryCacheCommitable = () => () => void;
-
-type QueryResult = {
-  fragmentNode: ReaderFragment,
-  fragmentRef: mixed,
-};
-
-// Note that the status of a cache entry will be 'resolved' when partial
-// rendering is allowed, even if a fetch is ongoing. The pending status
-// is specifically to indicate that we should suspend.
-// Note also that the retainCount is different from the retain count of
-// an operation, which is maintained by the Environment. This retain
-// count is used in Legacy Timeouts mode to count how many components
-// are mounted that use the entry, plus one count for the temporary retain
-// before any components have mounted. It is unused when Legacy Timeouts
-// mode is off.
-type QueryCacheEntryStatus =
-  | {
-      status: 'resolved',
-      result: QueryResult,
-    }
-  | {
-      status: 'pending',
-      promise: Promise<void>,
-    }
-  | {
-      status: 'rejected',
-      error: Error,
-    };
-
-type QueryCacheEntry = {
-  ...QueryCacheEntryStatus,
-  onCommit: QueryCacheCommitable,
-  suspenseResource: SuspenseResource | null,
-};
-
-const DEFAULT_FETCH_POLICY = 'store-or-network';
-
-const WEAKMAP_SUPPORTED = typeof WeakMap === 'function';
-
-interface IMap<K, V> {
-  delete(key: K): boolean;
-  get(key: K): V | void;
-  set(key: K, value: V): IMap<K, V>;
-}
-
-type QueryCacheKey = string;
-
-class QueryCache {
-  _map: IMap<IEnvironment, Map<QueryCacheKey, QueryCacheEntry>>;
-
-  constructor() {
-    this._map = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();
-  }
-
-  get(environment: IEnvironment, key: QueryCacheKey): QueryCacheEntry | void {
-    let forEnv = this._map.get(environment);
-    if (!forEnv) {
-      forEnv = new Map();
-      this._map.set(environment, forEnv);
-    }
-    return forEnv.get(key);
-  }
-
-  set(
-    environment: IEnvironment,
-    key: QueryCacheKey,
-    value: QueryCacheEntry,
-  ): void {
-    let forEnv = this._map.get(environment);
-    if (!forEnv) {
-      forEnv = new Map();
-      this._map.set(environment, forEnv);
-    }
-    forEnv.set(key, value);
-  }
-
-  delete(environment: IEnvironment, key: QueryCacheKey): void {
-    const forEnv = this._map.get(environment);
-    if (!forEnv) {
-      return;
-    }
-    forEnv.delete(key);
-    if (forEnv.size === 0) {
-      this._map.delete(environment);
-    }
-  }
-}
-
-function createQueryCache(): QueryCache {
-  return new QueryCache();
-}
-
-const noopOnCommit = () => {
-  return () => undefined;
-};
-
-const noopPromise = new Promise<void>(() => {});
-
-function getQueryCacheKey(
-  operation: OperationDescriptor,
-  fetchPolicy: FetchPolicy,
-  renderPolicy: RenderPolicy,
-  fetchKey?: ?string | ?number,
-): QueryCacheKey {
-  return `${fetchPolicy}-${renderPolicy}-${operation.request.identifier}-${
-    fetchKey ?? ''
-  }`;
-}
-
-function constructQueryResult(operation: OperationDescriptor): QueryResult {
-  const rootFragmentRef = {
-    __id: operation.fragment.dataID,
-    __fragments: {
-      [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: IEnvironment,
-  queryOperationDescriptor: OperationDescriptor,
-  options?: {
-    fetchPolicy?: FetchPolicy,
-    renderPolicy?: RenderPolicy,
-    fetchKey?: ?string | ?number,
-    fetchObservable?: Observable<GraphQLResponse>,
-  },
-): [QueryResult, QueryCacheCommitable] {
-  const fetchPolicy = options?.fetchPolicy ?? DEFAULT_FETCH_POLICY;
-  const renderPolicy =
-    options?.renderPolicy ?? environment.UNSTABLE_getDefaultRenderPolicy();
-
-  const cache = getCacheForType(createQueryCache);
-
-  const cacheKey = getQueryCacheKey(
-    queryOperationDescriptor,
-    fetchPolicy,
-    renderPolicy,
-    options?.fetchKey,
-  );
-
-  const initialEntry = cache.get(environment, cacheKey);
-
-  function updateCache(
-    updater: QueryCacheEntryStatus => QueryCacheEntryStatus,
-  ) {
-    let 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
-    const newStatus: {...} = updater(currentEntry);
-    // $FlowExpectedError[cannot-spread-inexact] Flow cannot understand that this is valid...
-    cache.set(environment, cacheKey, {...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) {
-    let entry;
-    if (initialEntry === undefined) {
-      onCacheMiss(
-        environment,
-        queryOperationDescriptor,
-        fetchPolicy,
-        renderPolicy,
-        updateCache,
-        options?.fetchObservable,
-      );
-      const createdEntry = cache.get(environment, cacheKey);
-      invariant(
-        createdEntry !== undefined,
-        'An entry should have been created by onCacheMiss. This is a bug in Relay.',
-      );
-      entry = createdEntry;
-    } else {
-      entry = initialEntry;
-    }
-    if (!entry.suspenseResource) {
-      entry.suspenseResource = new SuspenseResource(() => {
-        const retention = environment.retain(queryOperationDescriptor);
-        return {
-          dispose: () => {
-            retention.dispose();
-            cache.delete(environment, cacheKey);
-          },
-        };
-      });
-    }
-    if (entry.onCommit === noopOnCommit) {
-      entry.onCommit = () => {
-        invariant(
-          entry.suspenseResource,
-          'SuspenseResource should have been initialized. This is a bug in Relay.',
-        );
-        const retention = entry.suspenseResource.permanentRetain(environment);
-        return () => {
-          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?.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.
-      const retention = environment.retain(queryOperationDescriptor);
-
-      const dispose = () => {
-        retention.dispose();
-        cache.delete(environment, cacheKey);
-      };
-      const abortSignal = getCacheSignal();
-      abortSignal.addEventListener('abort', dispose, {once: true});
-    }
-  }
-
-  const entry = cache.get(environment, cacheKey); // could be a different entry now if synchronously resolved
-  invariant(
-    entry !== undefined,
-    'An entry should have been created by onCacheMiss. This is a bug in Relay.',
-  );
-  switch (entry.status) {
-    case 'pending':
-      throw entry.promise;
-    case 'rejected':
-      throw entry.error;
-    case 'resolved':
-      return [entry.result, entry.onCommit];
-  }
-  invariant(false, 'switch statement should be exhaustive');
-}
-
-function onCacheMiss(
-  environment: IEnvironment,
-  operation: OperationDescriptor,
-  fetchPolicy: FetchPolicy,
-  renderPolicy: RenderPolicy,
-  updateCache: ((QueryCacheEntryStatus) => QueryCacheEntryStatus) => void,
-  customFetchObservable?: Observable<GraphQLResponse>,
-): void {
-  // 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.
-  const queryAvailability = environment.check(operation);
-  const queryStatus = queryAvailability.status;
-  const hasFullQuery = queryStatus === 'available';
-  const canPartialRender =
-    hasFullQuery || (renderPolicy === 'partial' && queryStatus !== 'stale');
-
-  let shouldFetch;
-  let 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(existing => {
-      switch (existing.status) {
-        case 'resolved':
-          return existing;
-        case 'rejected':
-          return existing;
-        case 'pending':
-          return shouldRenderNow
-            ? {
-                status: 'resolved',
-                result: constructQueryResult(operation),
-              }
-            : existing;
-      }
-    });
-  } else {
-    invariant(
-      shouldRenderNow,
-      'Should either fetch or be willing to render. This is a bug in Relay.',
-    );
-    updateCache(_existing => ({
-      status: 'resolved',
-      result: constructQueryResult(operation),
-    }));
-  }
-}
-
-function executeOperationAndKeepUpToDate(
-  environment: IEnvironment,
-  operation: OperationDescriptor,
-  updateCache: ((QueryCacheEntryStatus) => QueryCacheEntryStatus) => void,
-  customFetchObservable?: Observable<GraphQLResponse>,
-) {
-  let resolvePromise;
-  const promise = new Promise<void>(r => {
-    resolvePromise = r;
-  });
-  // $FlowExpectedError[prop-missing] Expando to annotate Promises.
-  promise.displayName = 'Relay(' + operation.request.node.operation.name + ')';
-
-  let isFirstPayload = true;
-
-  // FIXME We may still need to cancel network requests for live queries.
-  const fetchObservable =
-    customFetchObservable ?? fetchQueryInternal(environment, operation);
-  fetchObservable.subscribe({
-    start: subscription => {},
-    error: error => {
-      if (isFirstPayload) {
-        updateCache(_existing => ({
-          status: 'rejected',
-          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
-        warning(
-          false,
-          'getQueryResultOrFetchQuery: An incremental payload for query `%` returned an error: `%`:`%`.',
-          operation.request.node.operation.name,
-          error.message,
-          error.stack,
-        );
-      }
-      resolvePromise();
-      isFirstPayload = false;
-    },
-    next: response => {
-      // Stop suspending on the first payload because of streaming, defer, etc.
-      updateCache(_existing => ({
-        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(existing =>
-    existing.status === 'pending' ? {status: 'pending', promise} : existing,
-  );
-}
-
-module.exports = getQueryResultOrFetchQuery_REACT_CACHE;

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

@@ -1,70 +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';
-
-import type {
-  CacheConfig,
-  FetchPolicy,
-  Query,
-  RenderPolicy,
-  Variables,
-} from 'relay-runtime';
-
-const {useTrackLoadQueryInRender} = require('../loadQuery');
-const useMemoOperationDescriptor = require('../useMemoOperationDescriptor');
-const useRelayEnvironment = require('../useRelayEnvironment');
-const getQueryResultOrFetchQuery = require('./getQueryResultOrFetchQuery_REACT_CACHE');
-const useFragmentInternal = require('./useFragmentInternal_REACT_CACHE');
-const {useEffect} = require('react');
-
-function useLazyLoadQuery_REACT_CACHE<TVariables: Variables, TData>(
-  gqlQuery: Query<TVariables, TData>,
-  variables: TVariables,
-  options?: {
-    fetchKey?: string | number,
-    fetchPolicy?: FetchPolicy,
-    networkCacheConfig?: CacheConfig,
-    UNSTABLE_renderPolicy?: RenderPolicy,
-  },
-): TData {
-  useTrackLoadQueryInRender();
-  const environment = useRelayEnvironment();
-
-  const queryOperationDescriptor = useMemoOperationDescriptor(
-    gqlQuery,
-    variables,
-    options?.networkCacheConfig ?? {force: true},
-  );
-
-  // Get the query going if needed -- this may suspend.
-  const [queryResult, effect] = getQueryResultOrFetchQuery(
-    environment,
-    queryOperationDescriptor,
-    {
-      fetchPolicy: options?.fetchPolicy,
-      renderPolicy: options?.UNSTABLE_renderPolicy,
-      fetchKey: options?.fetchKey,
-    },
-  );
-
-  useEffect(effect);
-
-  // Read the query's root fragment -- this may suspend.
-  const {fragmentNode, fragmentRef} = queryResult;
-  // $FlowExpectedError[incompatible-return] Is this a fixable incompatible-return?
-  return useFragmentInternal(fragmentNode, fragmentRef, 'useLazyLoadQuery()', {
-    fetchPolicy: options?.fetchPolicy,
-    networkCacheConfig: options?.networkCacheConfig,
-  });
-}
-
-module.exports = useLazyLoadQuery_REACT_CACHE;

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

@@ -1,150 +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';
-
-import type {PreloadedQuery} from '../EntryPointTypes.flow';
-import type {
-  GraphQLTaggedNode,
-  OperationType,
-  RenderPolicy,
-} from 'relay-runtime';
-
-const {useTrackLoadQueryInRender} = require('../loadQuery');
-const useMemoOperationDescriptor = require('../useMemoOperationDescriptor');
-const useRelayEnvironment = require('../useRelayEnvironment');
-const getQueryResultOrFetchQuery = require('./getQueryResultOrFetchQuery_REACT_CACHE');
-const useFragmentInternal = require('./useFragmentInternal_REACT_CACHE');
-const invariant = require('invariant');
-const {useDebugValue, useEffect} = require('react');
-const {
-  __internal: {fetchQueryDeduped, fetchQuery},
-} = require('relay-runtime');
-const warning = require('warning');
-
-function usePreloadedQuery_REACT_CACHE<TQuery: OperationType>(
-  gqlQuery: GraphQLTaggedNode,
-  preloadedQuery: PreloadedQuery<TQuery>,
-  options?: {
-    UNSTABLE_renderPolicy?: RenderPolicy,
-  },
-): TQuery['response'] {
-  const environment = useRelayEnvironment();
-
-  useTrackLoadQueryInRender();
-
-  const {fetchKey, fetchPolicy, source, variables, networkCacheConfig} =
-    preloadedQuery;
-  const operation = useMemoOperationDescriptor(
-    gqlQuery,
-    variables,
-    networkCacheConfig,
-  );
-
-  let fetchObservable;
-  if (preloadedQuery.kind === 'PreloadedQuery_DEPRECATED') {
-    invariant(
-      operation.request.node.params.name === preloadedQuery.name,
-      'usePreloadedQuery(): Expected data to be prefetched for query `%s`, ' +
-        'got prefetch results for query `%s`.',
-      operation.request.node.params.name,
-      preloadedQuery.name,
-    );
-    fetchObservable = fetchQueryDeduped(
-      environment,
-      operation.request.identifier,
-      () => {
-        if (environment === preloadedQuery.environment && source != null) {
-          return environment.executeWithSource({operation, source});
-        } else {
-          return environment.execute({operation});
-        }
-      },
-    );
-  } else {
-    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.',
-    );
-    const 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
-      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.',
-      );
-      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.
-  const [queryResult, effect] = getQueryResultOrFetchQuery(
-    environment,
-    operation,
-    {
-      fetchPolicy,
-      renderPolicy: options?.UNSTABLE_renderPolicy,
-      fetchKey,
-      fetchObservable,
-    },
-  );
-
-  useEffect(effect);
-
-  // Read the query's root fragment -- this may suspend.
-  const {fragmentNode, fragmentRef} = queryResult;
-  const data = useFragmentInternal(
-    fragmentNode,
-    fragmentRef,
-    'usePreloadedQuery()',
-    {
-      fetchPolicy: fetchPolicy,
-      networkCacheConfig: networkCacheConfig,
-    },
-  );
-
-  if (__DEV__) {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    useDebugValue({
-      query: preloadedQuery.name,
-      variables: preloadedQuery.variables,
-      data,
-      fetchKey,
-      fetchPolicy,
-      renderPolicy: options?.UNSTABLE_renderPolicy,
-    });
-  }
-
-  return data;
-}
-
-module.exports = usePreloadedQuery_REACT_CACHE;