Referencia

ascua-query

Consultas, mutaciones y la caché a mano, con su firma.

ts
import { cancel, clearCache, configure, getData, invalidate, mutation, prefetch, remote, setData } from "ascua-query";

2,15 kB gzip. Depende de ascua. La guía está en Datos remotos.

remote

ts
type QueryKey = readonly unknown[];

function remote<K extends QueryKey, T, R = T>(options: {
  key: () => K | null | undefined | false;
  load: (key: K, info: { signal: AbortSignal }) => Promise<T>;
  staleTime?: number;      // 0
  gcTime?: number;         // 5 minutos
  retry?: number;          // 3
  retryDelay?: (attempt: number) => number;
  refetchOnFocus?: boolean; // true
  interval?: number | false | (() => number | false);
  keepPrevious?: boolean;
  select?: (data: T) => R;
}): Remote<R>;

interface Remote<R> {
  (): R | undefined;
  state(): "idle" | "loading" | "ready" | "error";
  loading(): boolean;
  error(): unknown;
  placeholder(): boolean;
  updatedAt(): number;
  reload(): Promise<void>;
}

Carga al crearse si no hay datos frescos para la clave, y cada vez que la clave cambia. Las claves se comparan por valor: ["f", { a: 1, b: 2 }] y ["f", { b: 2, a: 1 }] son la misma. Se suscribe a la caché mientras vive el scope en que se creó.

mutation

ts
function mutation<V = void, R = unknown, C = unknown>(options: {
  run: (variables: V) => Promise<R>;
  onMutate?: (variables: V) => C | Promise<C>;
  onSuccess?: (data: R, variables: V, context: C | undefined) => unknown;
  onError?: (error: unknown, variables: V, context: C | undefined) => unknown;
  onSettled?: (data: R | undefined, error: unknown, variables: V, context: C | undefined) => unknown;
}): Mutation<V, R>;

interface MutateCallbacks<V, R> {
  onSuccess?: (data: R, variables: V) => unknown;
  onError?: (error: unknown, variables: V) => unknown;
  onSettled?: (data: R | undefined, error: unknown, variables: V) => unknown;
}

interface Mutation<V, R> {
  mutate(variables: V, callbacks?: MutateCallbacks<V, R>): void;
  mutateAsync(variables: V, callbacks?: MutateCallbacks<V, R>): Promise<R>;
  state(): "idle" | "pending" | "success" | "error";
  pending(): boolean;
  data(): R | undefined;
  error(): unknown;
  reset(): void;
}

Los on… se esperan si devuelven una promesa. Si se lanza otra antes de que termine la anterior, el estado es el de la última. Los callbacks de una llamada corren después de los de la mutación, y solo los de la última.

invalidate

ts
function invalidate(prefix?: QueryKey, options?: { refetch?: boolean }): Promise<void>;

Caduca todo lo que empieza por prefix (sin prefijo, todo). Lo que alguna vista mira se recarga ya, salvo con refetch: false.

getData, setData

ts
function getData<T>(key: QueryKey): T | undefined;
function setData<T>(key: QueryKey, value: T | ((old: T | undefined) => T)): T;

Leen y escriben la caché de una clave exacta. setData deja los datos como recién llegados.

cancel

ts
function cancel(prefix?: QueryKey): Promise<void>;

Corta las cargas en camino de lo que empieza por prefix.

prefetch

ts
function prefetch<K extends QueryKey, T>(
  key: K,
  load: (key: K, info: { signal: AbortSignal }) => Promise<T>,
  options?: Partial<QueryDefaults>,
): Promise<void>;

configure, clearCache

ts
function configure(options: Partial<QueryDefaults>): void;
function clearCache(): void;