@rest-hooks/redux

Asynchronous dynamic data at scale. Performance, data integrity, and typing for REST, proto, GraphQL, websockets and more..

📖Read The Docs  |  🏁Getting Started  |  🎮Todo Demo  |  🎮Github Demo

Simple TypeScript definition

class Article extends Entity {
  readonly id: string = '';
  readonly title: string = '';
  readonly body: string = '';

  pk() {
    return this.id;
  }
}

Create collection of API Endpoints

const ArticleResource = createResource({
  path: '/articles/:id',
  schema: Article,
})

One line data binding

const article = useSuspense(ArticleResource.get, { id });
return (
  <>
    <h2>{article.title}</h2>
    <p>{article.body}</p>
  </>
);

Mutation

const ctrl = useController();
return (
  <ArticleForm
    onSubmit={data => ctrl.fetch(ArticleResource.update, { id }, data)}
  />
);

And subscriptions

const price = useSuspense(PriceResource.get, { symbol });
useSubscription(PriceResource.get, { symbol });
return price.value;

Programmatic queries

const sortedArticles = new Query(
  new schema.All(Article),
  (entries, { asc } = { asc: false }) => {
    const sorted = [...entries].sort((a, b) => a.title.localeCompare(b.title));
    if (asc) return sorted;
    return sorted.reverse();
  }
);

const articlesUnsorted = useCache(sortedArticles);
const articlesAscending = useCache(sortedArticles, { asc: true });
const articlesDescending = useCache(sortedArticles, { asc: false });

...all typed ...fast ...and consistent

🏁Get started now

Features

• [x] Strong Typescript types
• [x] 🛌 React Suspense support
• [x] 🧵 React 18 Concurrent mode compatible
• [x] 🎣 Declarative API
• [x] 📝 Composition over configuration
• [x] 💰 Normalized caching
• [x] 💥 Tiny bundle footprint
• [x] 🛑 Automatic overfetching elimination
• [x] ✨ Optimistic updates
• [x] 🧘 Flexible to fit any API design (one size fits all)
• [x] 🔧 Debugging and inspection via browser extension
• [x] 🌳 Tree-shakable (only use what you need)
• [x] 🔁 Subscriptions
• [x] ♻️ Optional redux integration
• [x] 📙 Storybook mocking
• [x] 📱 React Native support
• [x] 🚯 Declarative cache lifetime policy

Principals of Data Client

Integrity

• Strong inferred types
• Global referential equality guarantees
• Normalized store creates a single source of truth
• Strong invariants robust against race conditions
• Validation

Performance

• Stale While Revalidate configurable cache
• Only re-render

Composition over configuration

• Declarative data definitions
• Decoupled API definitions from usage
• Co-located data dependencies
  • Centralized orchestration
• Extensible orchestration through Managers (middleware)
• Composable hooks
  • subject pattern
• Suspense + concurrent mode async orchestration

Incremental Adoption

• Simple case is simple
• Scale as your app scales