# @open-draft/until

> Gracefully handle a Promise using async/await.

Latest version **3.0.1** (published 2025-09-20) · MIT license · 0 weekly downloads

## Install

```sh
npm install @open-draft/until
pnpm add @open-draft/until
yarn add @open-draft/until
bun add @open-draft/until
```

## Health

**Score 65/100 (B)** — status: stable.

Positive: has types; esm support; no vulnerabilities; high maintenance score; high quality score.

Warnings: low downloads.

## Facts

| | |
|---|---|
| Version | 3.0.1 |
| Published | 2025-09-20 |
| First published | 2020-03-24 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | ESM + CommonJS |
| Dependencies | 0 |
| Unpacked size | 9.2 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 629 |
| Author | Artem Zakharchenko |
| Maintainers | kettanaito |
| Keywords | async, promise, handle, gracefully, tuple, util |

## Links

- npm: https://www.npmjs.com/package/@open-draft/until
- Repository: https://github.com/open-draft/until
- Issues: https://github.com/open-draft/until/issues
- Funding: https://github.com/sponsors/kettanaito
- npm.io page: https://npm.io/package/@open-draft/until

## Alternatives

- [@commercetools/sync-actions](https://npm.io/package/@commercetools/sync-actions.md) — 25.1K weekly downloads
- [cwait](https://npm.io/package/cwait.md) — 21.4K weekly downloads
- [@ledgerhq/hw-app-cosmos](https://npm.io/package/@ledgerhq/hw-app-cosmos.md) — 4.2K weekly downloads
- [@financial-times/o-loading](https://npm.io/package/@financial-times/o-loading.md) — 2.8K weekly downloads
- [fa](https://npm.io/package/fa.md) — 185 weekly downloads

## Recent versions

- 3.0.1 (latest) — 2025-09-20
- 3.0.0 — 2025-09-20
- 2.1.0 — 2023-04-18
- 2.0.0 — 2022-02-16
- 1.0.3 — 2020-05-31
- 1.0.2 — 2020-03-24
- 1.0.1 — 2020-03-24
- 1.0.0 — 2020-03-24

## README

> ⚠️ **This package has been re-published as [`until-async`](https://www.npmjs.com/package/until-async)**. Please update to that package instead as it will receive updates and fixes from now on. Thank you.

# `until`

Gracefully handle a Promise using `async`/`await`.

## Why?

With the addition of `async`/`await` keywords in ECMAScript 2017 the handling of Promises became much easier. However, one must keep in mind that the `await` keyword provides no standard error handling API. Consider this usage:

```js
async function getUser(id) {
  const data = await fetchUser(id)
  // Work with "data"...
}
```

In case `fetchUser()` throws an error, the entire `getUser()` function's scope will terminate. Because of this, it's recommended to implement error handling using `try`/`catch` block wrapping `await` expressions:

```js
async function getUser(id) {
  let data = null

  try {
    data = await asyncAction()
  } catch (error) {
    console.error(error)
  }

  // Work with "data"...
}
```

While this is a semantically valid approach, constructing `try`/`catch` around each awaited operation may be tedious and get overlooked at times. Such error handling also introduces separate closures for execution and error scenarios of an asynchronous operation.

This library encapsulates the `try`/`catch` error handling in a utility function that does not create a separate closure and exposes a NodeJS-friendly API to work with errors and resolved data.

## Getting started

### Install

```bash
npm install @open-draft/until
```

### Usage

```js
import { until } from '@open-draft/until'

async function getUserById(id) {
  const [error, data] = await until(() => fetchUser(id))

  if (error) {
    return handleError(error)
  }

  return data
}
```

### Usage with TypeScript

```ts
import { until } from '@open-draft/until'

interface User {
  firstName: string
  age: number
}

interface UserFetchError {
  type: 'FORBIDDEN' | 'NOT_FOUND'
  message?: string
}

async function getUserById(id: string) {
  const [error, data] = await until<UserFetchError, User>(() => fetchUser(id))

  if (error) {
    return handleError(error.type, error.message)
  }

  return data.firstName
}
```

## Frequently asked questions

### Why does `until` accept a function and not a `Promise` directly?

This has been intentionally introduced to await a single logical unit as opposed to a single `Promise`.

```js
// Notice how a single "until" invocation can handle
// a rather complex piece of logic. This way any rejections
// or exceptions happening within the given function
// can be handled via the same "error".
const [error, data] = until(async () => {
  const user = await fetchUser()
  const nextUser = normalizeUser(user)
  const transaction = await saveModel('user', user)

  invariant(transaction.status === 'OK', 'Saving user failed')

  return transaction.result
})

if (error) {
  // Handle any exceptions happened within the function.
}
```

## Special thanks

- [giuseppegurgone](https://twitter.com/giuseppegurgone) for the discussion about the original `until` API.

---
_Source: https://npm.io/package/@open-draft/until · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._