react-query#UseQueryOptions TypeScript Examples

useProfileGearQuery = <
      TData = ProfileGearQuery,
      TError = unknown
    >(
      variables?: ProfileGearQueryVariables,
      options?: UseQueryOptions<ProfileGearQuery, TError, TData>
    ) =>
    useQuery<ProfileGearQuery, TError, TData>(
      variables === undefined ? ['ProfileGear'] : ['ProfileGear', variables],
      useFetchData<ProfileGearQuery, ProfileGearQueryVariables>(ProfileGearDocument).bind(null, variables),
      options
    )

useParsedAccount = <T>(
  key: PublicKey | null | undefined,
  parser: ProgramAccountParser<T>,
  options: Omit<
    UseQueryOptions<ProgramAccount<T> | null | undefined>,
    "queryFn" | "queryKey"
  > = {}
): ParsedAccountQueryResult<T> => {
  const { fetchKeys, onBatchCache } = useSail();
  const { network } = useSolana();

  const query = useQuery(
    makeParsedAccountQuery(key, network, fetchKeys, parser, options)
  );

  useAccountsSubscribe(useMemo(() => [key], [key]));

  // refresh from the cache whenever the cache is updated
  const { refetch } = query;
  useEffect(() => {
    if (!key) {
      return;
    }
    return onBatchCache((e) => {
      if (e.hasKey(key)) {
        void refetch();
      }
    });
  }, [key, fetchKeys, onBatchCache, refetch]);

  return query;
}

useBatchedParsedAccounts = <T>(
  keys: BatchedParsedAccountQueryKeys,
  parser: ProgramAccountParser<T>,
  options: Omit<
    UseQueryOptions<BatchedParsedAccountQueryData<T>>,
    "queryFn" | "queryKey"
  > = {}
): BatchParsedAccountQueryResult<T> => {
  const { fetchKeys, onBatchCache } = useSail();
  const { network } = useSolana();

  const query = useQuery(
    makeBatchedParsedAccountQuery(keys, network, fetchKeys, parser, options)
  );

  useAccountsSubscribe(keys);

  // refresh from the cache whenever the cache is updated
  const { refetch } = query;
  useEffect(() => {
    if (!keys) {
      return;
    }
    return onBatchCache((e) => {
      if (keys.find((key) => key && e.hasKey(key))) {
        void refetch();
      }
    });
  }, [keys, fetchKeys, onBatchCache, refetch]);

  return query;
}

makeTokenQuery = ({
  network,
  address,
  fetchKeys,
}: {
  network: Network;
  address: PublicKey | null | undefined;
  fetchKeys: FetchKeysFn;
}): UseQueryOptions<Token | null | undefined> => ({
  queryKey: ["sail/tokenInfo", network, address?.toString()],
  queryFn: async ({ signal }): Promise<Token | null | undefined> => {
    if (address === null || address === undefined) {
      return address;
    }
    const chainId = networkToChainId(network);
    const info = await fetchNullableWithSessionCache<TokenInfo>(
      makeCertifiedTokenInfoURL(chainId, address.toString()),
      signal
    );
    if (info !== null) {
      return new Token(info);
    }
    const [tokenData] = await fetchKeys([address]);
    if (!tokenData) {
      return null;
    }
    if (!tokenData.data) {
      return tokenData.data;
    }
    const raw = tokenData.data.accountInfo.data;
    const parsed = deserializeMint(raw);
    return Token.fromMint(address, parsed.decimals, {
      chainId: networkToChainId(network),
    });
  },
  // these should never be stale, since token mints are immutable (other than supply)
  staleTime: Infinity,
})

makeCertifiedTokenQuery = (
  network: Network,
  address: string | null | undefined
): UseQueryOptions<Token | null | undefined> => ({
  queryKey: ["sail/certifiedTokenInfo", network, address],
  queryFn: async ({ signal }): Promise<Token | null | undefined> => {
    if (address === null || address === undefined) {
      return address;
    }
    const chainId = networkToChainId(network);
    const info = await fetchNullableWithSessionCache<TokenInfo>(
      makeCertifiedTokenInfoURL(chainId, address),
      signal
    );
    if (info === null) {
      return null;
    }
    return new Token(info);
  },
  // these should never be stale, since token mints are immutable (other than supply)
  staleTime: Infinity,
})

export function useDataQuery(
  dataUrl: string,
  queryId: string | null,
  params: any,
  options: Pick<
    UseQueryOptions<any, unknown, unknown, any[]>,
    'refetchOnWindowFocus' | 'refetchOnReconnect' | 'refetchInterval'
  >,
): UseDataQuery {
  const {
    isLoading,
    isFetching,
    error,
    data: responseData = EMPTY_OBJECT,
    refetch,
  } = useQuery([dataUrl, queryId, params], () => queryId && fetchData(dataUrl, queryId, params), {
    ...options,
    enabled: !!queryId,
  });

  const { data } = responseData;

  const rows = Array.isArray(data) ? data : EMPTY_ARRAY;

  const result: UseDataQuery = React.useMemo(
    () => ({
      isLoading,
      isFetching,
      error,
      data,
      rows,
      refetch,
    }),
    [isLoading, isFetching, error, data, rows, refetch],
  );

  return result;
}

useWalletQuery = <
      TData = WalletQuery,
      TError = unknown
    >(
      variables?: WalletQueryVariables,
      options?: UseQueryOptions<WalletQuery, TError, TData>
    ) =>
    useQuery<WalletQuery, TError, TData>(
      variables === undefined ? ['Wallet'] : ['Wallet', variables],
      useFetchData<WalletQuery, WalletQueryVariables>(WalletDocument).bind(null, variables),
      options
    )

useSearchDopeQuery = <
      TData = SearchDopeQuery,
      TError = unknown
    >(
      variables: SearchDopeQueryVariables,
      options?: UseQueryOptions<SearchDopeQuery, TError, TData>
    ) =>
    useQuery<SearchDopeQuery, TError, TData>(
      ['SearchDope', variables],
      useFetchData<SearchDopeQuery, SearchDopeQueryVariables>(SearchDopeDocument).bind(null, variables),
      options
    )

useRenderDopeQuery = <
      TData = RenderDopeQuery,
      TError = unknown
    >(
      variables?: RenderDopeQueryVariables,
      options?: UseQueryOptions<RenderDopeQuery, TError, TData>
    ) =>
    useQuery<RenderDopeQuery, TError, TData>(
      variables === undefined ? ['RenderDope'] : ['RenderDope', variables],
      useFetchData<RenderDopeQuery, RenderDopeQueryVariables>(RenderDopeDocument).bind(null, variables),
      options
    )

useProfileHustlersQuery = <
      TData = ProfileHustlersQuery,
      TError = unknown
    >(
      variables?: ProfileHustlersQueryVariables,
      options?: UseQueryOptions<ProfileHustlersQuery, TError, TData>
    ) =>
    useQuery<ProfileHustlersQuery, TError, TData>(
      variables === undefined ? ['ProfileHustlers'] : ['ProfileHustlers', variables],
      useFetchData<ProfileHustlersQuery, ProfileHustlersQueryVariables>(ProfileHustlersDocument).bind(null, variables),
      options
    )

useProfileDopesQuery = <
      TData = ProfileDopesQuery,
      TError = unknown
    >(
      variables?: ProfileDopesQueryVariables,
      options?: UseQueryOptions<ProfileDopesQuery, TError, TData>
    ) =>
    useQuery<ProfileDopesQuery, TError, TData>(
      variables === undefined ? ['ProfileDopes'] : ['ProfileDopes', variables],
      useFetchData<ProfileDopesQuery, ProfileDopesQueryVariables>(ProfileDopesDocument).bind(null, variables),
      options
    )

useItemQuery = <
      TData = ItemQuery,
      TError = unknown
    >(
      variables?: ItemQueryVariables,
      options?: UseQueryOptions<ItemQuery, TError, TData>
    ) =>
    useQuery<ItemQuery, TError, TData>(
      variables === undefined ? ['Item'] : ['Item', variables],
      useFetchData<ItemQuery, ItemQueryVariables>(ItemDocument).bind(null, variables),
      options
    )

useHustlerQuery = <
      TData = HustlerQuery,
      TError = unknown
    >(
      variables?: HustlerQueryVariables,
      options?: UseQueryOptions<HustlerQuery, TError, TData>
    ) =>
    useQuery<HustlerQuery, TError, TData>(
      variables === undefined ? ['Hustler'] : ['Hustler', variables],
      useFetchData<HustlerQuery, HustlerQueryVariables>(HustlerDocument).bind(null, variables),
      options
    )

useAnchorQuery = <
  TQueryFnData = unknown,
  TError = unknown,
  TData = TQueryFnData,
  TQueryKey extends QueryKey = QueryKey,
>(
  queryKey: TQueryKey,
  queryFn: QueryFunction<TQueryFnData, TQueryKey>,
  options?: Omit<
    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
    'queryKey' | 'queryFn'
  >,
): UseQueryResult<TData, TError> => {
  const { queryErrorReporter } = useApp();

  return useQuery(queryKey, queryFn, {
    onError: queryErrorReporter,
    ...options,
  });
}

function useApi<T extends Method>(
  method: T,
  params: Parameters<ApiClient[T]> = [] as Parameters<ApiClient[T]>,
  options?: UseQueryOptions<Methods[T]>,
) {
  const client = useMemo(() => new ApiClient(), []);
  const query = useQuery<Methods[T]>(
    [method, ...params],
    () =>
      // @ts-expect-error
      client[method](...params) as Methods[T],
    options,
  );

  return query;
}

useDrugQuery = <
      TData = DrugQuery,
      TError = unknown
    >(
      variables?: DrugQueryVariables,
      options?: UseQueryOptions<DrugQuery, TError, TData>
    ) =>
    useQuery<DrugQuery, TError, TData>(
      variables === undefined ? ['Drug'] : ['Drug', variables],
      useFetchData<DrugQuery, DrugQueryVariables>(DrugDocument).bind(null, variables),
      options
    )

useDrugsQuery = <
      TData = DrugsQuery,
      TError = unknown
    >(
      variables?: DrugsQueryVariables,
      options?: UseQueryOptions<DrugsQuery, TError, TData>
    ) =>
    useQuery<DrugsQuery, TError, TData>(
      variables === undefined ? ['Drugs'] : ['Drugs', variables],
      useFetchData<DrugsQuery, DrugsQueryVariables>(DrugsDocument).bind(null, variables),
      options
    )

useAllHustlersQuery = <
      TData = AllHustlersQuery,
      TError = unknown
    >(
      variables?: AllHustlersQueryVariables,
      options?: UseQueryOptions<AllHustlersQuery, TError, TData>
    ) =>
    useQuery<AllHustlersQuery, TError, TData>(
      variables === undefined ? ['AllHustlers'] : ['AllHustlers', variables],
      useFetchData<AllHustlersQuery, AllHustlersQueryVariables>(AllHustlersDocument).bind(null, variables),
      options
    )

useAllItemsQuery = <
      TData = AllItemsQuery,
      TError = unknown
    >(
      variables?: AllItemsQueryVariables,
      options?: UseQueryOptions<AllItemsQuery, TError, TData>
    ) =>
    useQuery<AllItemsQuery, TError, TData>(
      variables === undefined ? ['AllItems'] : ['AllItems', variables],
      useFetchData<AllItemsQuery, AllItemsQueryVariables>(AllItemsDocument).bind(null, variables),
      options
    )

useDopeListingQuery = <
      TData = DopeListingQuery,
      TError = unknown
    >(
      variables?: DopeListingQueryVariables,
      options?: UseQueryOptions<DopeListingQuery, TError, TData>
    ) =>
    useQuery<DopeListingQuery, TError, TData>(
      variables === undefined ? ['DopeListing'] : ['DopeListing', variables],
      useFetchData<DopeListingQuery, DopeListingQueryVariables>(DopeListingDocument).bind(null, variables),
      options
    )

useDopesQuery = <
      TData = DopesQuery,
      TError = unknown
    >(
      variables?: DopesQueryVariables,
      options?: UseQueryOptions<DopesQuery, TError, TData>
    ) =>
    useQuery<DopesQuery, TError, TData>(
      variables === undefined ? ['Dopes'] : ['Dopes', variables],
      useFetchData<DopesQuery, DopesQueryVariables>(DopesDocument).bind(null, variables),
      options
    )

useHustlersWalletQuery = <
      TData = HustlersWalletQuery,
      TError = unknown
    >(
      variables?: HustlersWalletQueryVariables,
      options?: UseQueryOptions<HustlersWalletQuery, TError, TData>
    ) =>
    useQuery<HustlersWalletQuery, TError, TData>(
      variables === undefined ? ['HustlersWallet'] : ['HustlersWallet', variables],
      useFetchData<HustlersWalletQuery, HustlersWalletQueryVariables>(HustlersWalletDocument).bind(null, variables),
      options
    )

usePersonList = (options?: UseQueryOptions<PersonResponse[]>) => {
  const { data: session } = useSession()
  return useQuery<PersonResponse[]>(
    endpoints.person.list.url,
    authQueryFnFactory<PersonResponse[]>(session?.accessToken),
    options,
  )
}

export function useDashboardData<TData = DashboardData>(options?: UseQueryOptions<DashboardData, Error, TData>) {
  return useQuery(queryKeys.dashboardData(), () => getDashboardData(), options)
}

makeBatchedTokensQuery = ({
  network,
  addresses,
  fetchKeys,
}: {
  network: Network;
  addresses: BatchedParsedAccountQueryKeys;
  fetchKeys: FetchKeysFn;
}): UseQueryOptions<
  readonly (Token | null | undefined)[] | null | undefined
> => ({
  queryKey: [
    "sail/batchedTokens",
    network,
    ...(mapSome(addresses, (a) => a.map((address) => address?.toString())) ?? [
      addresses,
    ]),
  ],
  queryFn: async ({
    signal,
  }): Promise<readonly (Token | null | undefined)[] | null | undefined> => {
    const addressesToFetch: {
      key: PublicKey;
      index: number;
    }[] = [];

    if (!addresses) {
      return addresses;
    }

    const data = await Promise.all(
      addresses.map(async (address, i) => {
        if (address === null || address === undefined) {
          return address;
        }
        const chainId = networkToChainId(network);
        const info = await fetchNullableWithSessionCache<TokenInfo>(
          makeCertifiedTokenInfoURL(chainId, address.toString()),
          signal
        );
        if (info !== null) {
          return new Token(info);
        }
        addressesToFetch.push({ key: address, index: i });
      })
    );

    if (signal?.aborted) {
      throw new Error("Query aborted");
    }

    const tokenDatas = await fetchKeys(addressesToFetch.map((a) => a.key));
    tokenDatas.forEach((tokenData, i) => {
      const index = addressesToFetch[i]?.index;
      if (index === undefined) {
        return;
      }
      if (!tokenData || !tokenData.data) {
        data[index] = null;
        return;
      }
      const raw = tokenData.data.accountInfo.data;
      const parsed = deserializeMint(raw);
      const token = Token.fromMint(tokenData.data.accountId, parsed.decimals, {
        chainId: networkToChainId(network),
      });
      data[index] = token;
    });

    return data;
  },
  // these should never be stale, since token mints are immutable (other than supply)
  staleTime: Infinity,
})

makeProgramParserHooks = <M, A extends keyof M>(
  parsers: ProgramAccountParsers<M>
): {
  [K in A]: ProgramParserHooks<M[K]>;
} => {
  const sailParsers = makeProgramAccountParsers<M, A>(parsers);
  const hooks = mapValues(
    sailParsers,
    <T extends M[A]>(
      parser: ProgramAccountParser<T>
    ): ProgramParserHooks<T> => ({
      useSingleData: (
        key: PublicKey | null | undefined,
        options?: Omit<
          UseQueryOptions<ProgramAccount<T> | null | undefined>,
          "queryFn" | "queryKey"
        >
      ): ParsedAccountQueryResult<T> => useParsedAccount(key, parser, options),
      useData: (
        keys: (PublicKey | null | undefined)[],
        options?: Omit<
          UseQueryOptions<ProgramAccount<T> | null | undefined>,
          "queryFn" | "queryKey"
        >
      ): ParsedAccountQueryResult<T>[] =>
        useParsedAccounts<T>(keys, parser, options),
      useBatchedData: (
        keys: BatchedParsedAccountQueryKeys,
        options?: Omit<
          UseQueryOptions<BatchedParsedAccountQueryData<T>>,
          "queryFn" | "queryKey"
        >
      ): BatchParsedAccountQueryResult<T> =>
        useBatchedParsedAccounts<T>(keys, parser, options),
    })
  );
  return hooks as unknown as {
    [K in A]: ProgramParserHooks<M[K]>;
  };
}

makeBatchedParsedAccountQuery = <T>(
  keys: BatchedParsedAccountQueryKeys,
  network: Network,
  fetchKeys: FetchKeysFn,
  parser: ProgramAccountParser<T>,
  options: Omit<
    UseQueryOptions<BatchedParsedAccountQueryData<T>>,
    "queryFn" | "queryKey"
  > = {}
): UseQueryOptions<BatchedParsedAccountQueryData<T>> => ({
  queryKey: [
    "sail/batchedParsedAccounts",
    network,
    ...(keys ? serializeKeys(keys) : keys === null ? ["null"] : ["undefined"]),
  ],
  queryFn: async (): Promise<BatchedParsedAccountQueryData<T>> => {
    if (!keys) {
      return keys;
    }
    const accountsData = await fetchKeysMaybe(fetchKeys, keys);
    return accountsData.map((result): ProgramAccount<T> | null | undefined => {
      if (!result) {
        return result;
      }
      const data = result.data;
      if (!data) {
        return null;
      }

      try {
        const parsed = parser.parse(data.accountInfo.data);
        return {
          publicKey: data.accountId,
          account: parsed,
        };
      } catch (e) {
        throw new SailProgramAccountParseError(e, data, parser);
      }
    });
  },
  staleTime: Infinity,
  ...options,
})

useParsedAccounts = <T>(
  keys: (PublicKey | null | undefined)[],
  parser: ProgramAccountParser<T>,
  options: Omit<
    UseQueryOptions<ProgramAccount<T> | null | undefined>,
    "queryFn" | "queryKey"
  > = {}
): ParsedAccountQueryResult<T>[] => {
  const { network } = useSolana();
  const data = useAccountsData(keys);
  return useQueries(
    keys.map(
      (key, i): UseQueryOptions<ProgramAccount<T> | null | undefined> => {
        const datum = data[i];
        return {
          queryKey: [
            "sail/parsedAccount",
            network,
            parser.programID.toString(),
            parser.name,
            key ? key.toString() : key,
          ],
          queryFn: () => {
            if (!datum) {
              return datum;
            }
            try {
              const parsed = parser.parse(datum.accountInfo.data);
              return { publicKey: datum.accountId, account: parsed };
            } catch (e) {
              throw new SailProgramAccountParseError(e, datum, parser);
            }
          },
          enabled: key !== undefined && datum !== undefined,
          ...options,
        };
      }
    )
  );
}

makeParsedAccountQuery = <T>(
  key: PublicKey | null | undefined,
  network: Network,
  fetchKeys: FetchKeysFn,
  parser: ProgramAccountParser<T>,
  options: Omit<
    UseQueryOptions<ProgramAccount<T> | null | undefined>,
    "queryFn" | "queryKey"
  > = {}
): UseQueryOptions<ProgramAccount<T> | null | undefined> => ({
  queryKey: [
    "sail/parsedAccount",
    network,
    parser.programID.toString(),
    parser.name,
    key ? key.toString() : key,
  ],
  queryFn: async (): Promise<ProgramAccount<T> | null | undefined> => {
    const [result] = await fetchKeysMaybe(fetchKeys, [key]);
    if (!result) {
      return result;
    }
    const data = result.data;
    if (!data) {
      return null;
    }

    try {
      const parsed = parser.parse(data.accountInfo.data);
      return {
        publicKey: data.accountId,
        account: parsed,
      };
    } catch (e) {
      throw new SailProgramAccountParseError(e, data, parser);
    }
  },
  staleTime: Infinity,
  enabled: key !== undefined,
  ...options,
})