Introduction

Type-safe error handling for TypeScript with retry logic and concurrency control

Welcome to Tryo

A modern, type-safe error handling library that makes async operations predictable and resilient.

Quick Start

Get up and running in less than 5 minutes

API Reference

Explore the complete API documentation

Examples

Real-world examples and patterns

GitHub

View source code and contribute

Features

Type-Safe Error Handling

No more try-catch blocks. Get discriminated unions with full TypeScript support.

const result = await runner.run(() => apiCall());
if (result.ok) {
  // TypeScript knows data is available
  console.log(result.data);
}

Smart Retry Logic

Built-in exponential backoff with jitter to prevent thundering herd.

await runner.run(() => unstableApi(), {
  retry: {
    maxRetries: 3,
    strategy: RetryStrategies.exponential(1000),
  }
});

Concurrency Control

Run multiple operations with controlled parallelism.

await runner.all(tasks, { 
  concurrency: 5 
});

Abort Handling

First-class support for AbortController and graceful cancellation.

await runner.run(() => fetch('/api', { signal }), {
  ignoreAbort: true
});

Installation

npm

npm install tryo

Quick Example

import tryo from "tryo";

const runner = tryo();

const result = await runner.run(() => fetch("https://api.example.com/users"), {
  retry: {
    maxRetries: 3,
    strategy: RetryStrategies.fixed(1000),
  },
  hooks: {
    onError: (error) => console.error(error),
  }
});

if (result.ok) {
  const users = await result.data.json();
  console.log(users);
}

Pro tip: Use tryo() once and reuse it across your app for consistent error handling.

Next Steps

Core Concepts

Learn about Result types and error normalization

React Integration

See how to use it with React hooks