❗ This package is no longer being actively maintained. ❗

rx-query

Batteries included fetching library Fetch your data with ease and give your users a better experience

Why

• a better user experience
• ease of use
• configurable
• promotes Push-based Architecture

Features

• Retries
• Cache
• Refresh on interval, focus, online
• Mutate data

Basics

Query without parameters

The most simple query is a parameter without parameters, it's just a wrapper around and Observable. The query method expects a callback method to invoke the query.

import { query } from "rx-query";

characters$ = query("characters", () =>
	this.rickAndMortyService.getCharacters(),
);

Query with static parameter

A query that has a static parameter (a value that doesn't change over time), can be written in the same way as a query without parameters.

import { query } from "rx-query";

characters$ = query("character", () =>
	this.rickAndMortyService.getCharacter(1),
);

An alternative way if to pass the static parameter as the first argument. The query callback will then be invoked with the passed parameter.

import { query } from "rx-query";

characters$ = query("character", 1, (characterId) =>
	this.rickAndMortyService.getCharacter(characterId),
);

Query with dynamic parameter

If a parameter can change over time (aka an Observable), it can also be passed as a parameter to query. When the input Observable emits a new value, the callback query will be invoked with the new input value.

character$ = query(
	"character",
	this.activatedRoute.params.pipe(map((p) => p.characterId)),
	(characterId: number) => this.rickAndMortyService.getCharacter(characterId),
);

Query status

A query can have the following:

• loading: when the query is being invoked and hasn't responded yet
• refreshing: when the query is being invoked, and there's a cached value (the cached value gets refreshed when the query is successful)
• success: when the query returns a successful response
• error: when the query threw an error
• mutating: when a mutation is in progress
• mutate-error: when a mutation threw an error

In the view layer you will often see a structure like this, with a segment to represent each status:

<ng-container *ngIf="characters$ | async as characters">
	<ng-container [ngSwitch]="characters.status">
		<div *ngSwitchCase="'loading'">Loading ... ({{ characters.retries }})</div>

		<div *ngSwitchCase="'error'">
			Something went wrong ... ({{ characters.retries }})
		</div>

		<div *ngSwitchDefault>
			<ul>
				<li *ngFor="let character of characters.data">
					<a [routerLink]="character.id">{{ character.name }}</a>
				</li>
			</ul>
		</div>
	</ng-container>
</ng-container>

Refresh a query

Use refreshQuery to trigger a new fetch from a previously contructed query.
Note that the key and parameters provided to refreshQuery should be exactly the same! The following will refetch the data and update the cache.

import { query, refreshQuery } from "rx-query";

character$ = query("character", 1, (id) =>
	this.rickAndMortyService.getCharacter(id),
);

// On some event
refreshQuery("character", 1);

Output

export type QueryOutput<QueryResult = unknown> = {
	status: Readonly<
		| "idle"
		| "success"
		| "error"
		| "loading"
		| "refreshing"
		| "mutating"
		| "mutate-error"
	>;
	data?: Readonly<QueryResult>;
	error?: Readonly<unknown>;
	retries?: Readonly<number>;
	mutate: (data: QueryResult) => void;
};

status

The current status of the query.

data

The result of the query, or the cached result.

error

The error object returned by the query. Only available in the error status.

retries

Number of query retries. Is reset every time data is fetched. Available on all statuses.

mutate

The mutate method to mutate the current query. This is optimistic, the data of the query will be modified while the request is pending. When the request resolves, the query data will be refreshed with the server data. If the request fails, the original data of the query will be restored.

Config

export type QueryConfig = {
	retries?: number | ((retryAttempt: number, error: unknown) => boolean);
	retryDelay?: number | ((retryAttempt: number) => number);
	refetchInterval?: number | Observable<unknown>;
	refetchOnWindowFocus?: boolean;
	refetchOnReconnect?: boolean;
	staleTime?: number;
	cacheTime?: number;
	mutator?: (data: QueryResult, params: QueryParam) => QueryResult;
};

retries

The number of retries to retry a query before ending up in the error status. Also accepts a callback method ((retryAttempt: number, error: unknown) => boolean) to give more control to the consumer. When a query is being retried, the status remains in the original (loading or refreshing) status. Example.

Default: 3

Usage:

{
	retries: 3,
}

{
  // Never retry when 3 attempts has been made already, or when the query is totally broken
	retries: (retryAttempt: number, error: string) =>
		retryAttempt < 3 && !error !== "Totally broken",
}

retryDelay

The delay in milliseconds before retrying the query. Also accepts a callback method ((retryAttempt: number) => number) to give more control to the consumer. Example.

Default: (n) => (n + 1) * 1000

Usage:

{
	retryDelay: 100,
}

{
  // Increase the delay with 1 second after every attempt
	retryDelay: (retryAttempt) => retryAttempt * 1000,
}

refetchInterval

Invoke the query in the background every x milliseconds, and emit the new value when the query is resolved. Example.

Default: Infinity

Usage:

{
  // every 5 minutes
	refetchInterval: 6000 * 5,
}

refetchOnWindowFocus

Invoke the query in the background when the window is focused, and emit the new value when the query is resolved. Example.

Default: true

Usage:

{
	refetchOnWindowFocus: false,
}

refetchOnReconnect

Invoke the query when the client goes back online.

Default: true

Usage:

{
	refetchOnReconnect: false,
}

cacheTime

Set the cache time (in milliseconds) for a query key. Example.

Default: 30_000 (5 minutes)

Usage:

{
	cacheTime: 60_000,
}

staleTime

Decides when a query should be refetched when it receives a trigger.

Default: 0

Usage:

{
	staleTime: 60_000,
}

mutator

The mutator, is the method that will be invoked when the mutate method is called. It receives the data passed to the mutate method and the current params of the query. Example.

Default: mutator: (data) => data

Usage:

{
  mutator: (data, queryOptions) =>
    this.http
      .post(`/persons/${queryOptions.queryParameters.id}`, data)
      // 👇 important to let the request throw in order to rollback
      .pipe(catchError((err) => throwError(err.statusText))),
}

Config override

To override the defaults for all queries, you can use the setQueryConfig method.

setQueryConfig({
	refetchOnWindowFocus: false,
	retries: 0,
	cacheTime: 60_000,
});

Inspiration

This library is inspired by:

• react-query, written by Tanner Linsley
• vercel/swr