Function useClientQuery

src/Utils/Hooks/useClientQuery.ts:24–172

({
  environment,
  query,
  variables = {},
  cacheConfig = {},
  skip = false,
}: {
  environment?: Environment
  query: GraphQLTaggedNode
  variables?: T["variables"]
  cacheConfig?: {
    networkCacheConfig?: CacheConfig | null | undefined
    fetchPolicy?: FetchQueryFetchPolicy | null | undefined
  } | null
  skip?: boolean
})

}

export const useClientQuery = <T extends OperationType>({
  environment,
  query,
  variables = {},
  cacheConfig = {},
  skip = false,
}: {
  environment?: Environment
  query: GraphQLTaggedNode
  variables?: T["variables"]
  cacheConfig?: {
    networkCacheConfig?: CacheConfig | null | undefined
    fetchPolicy?: FetchQueryFetchPolicy | null | undefined
  } | null
  skip?: boolean
}) => {
  const { relayEnvironment } = useSystemContext()

  const [data, setData] = useState<T["response"] | null>(null)
  const [error, setError] = useState<Error | null>(null)
  const [loading, setLoading] = useState(true)

  const key = useRef(JSON.stringify(variables))
  const prevKey = useRef(key.current)
  const retainedRef = useRef<Disposable | null>(null)

  useUpdateEffect(() => {
    key.current = JSON.stringify(variables)
  }, [variables])

  // Clean up retained operations on unmount
  useEffect(() => {
    return () => {
      if (retainedRef.current) {
        retainedRef.current.dispose()
        retainedRef.current = null
      }
    }
  }, [])

  // refetch returns an object with a `promise` that resolves when the network
  // response arrives and a `disposable` with a `dispose()` method that can be
  // used to cancel the in-flight subscription where supported.
  const refetch = (
    newVariables = variables,
  ): RefetchResult<T["response"] | null> => {
    setLoading(true)

    const env = (environment || relayEnvironment) as unknown as Environment

    // Validate environment
    if (!env) {
      const error = new Error("No Relay environment available")
      setError(error)
      setLoading(false)
      const rejectedPromise = Promise.reject(error).catch(() => null)
      return { promise: rejectedPromise, disposable: { dispose: () => {} } }
    }