open-draft/until

Gracefully handle Promises using async/await without try/catch.

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:

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:

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

npm install @open-draft/until

Usage

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

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.

// 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.
}

Why does until return an object and not an array?

The until function used to return an array of shape [error, data] prior to 2.0.0. That has been changed, however, to get proper type-safety using discriminated union type.

Compare these two examples:

const [error, data] = await until(() => action())

if (error) {
  return null
}

// Data still has ambiguous "DataType | null" type here
// even after you've checked and handled the "error" above.
console.log(data)

const result = await until(() => action())

// At this point, "data" is ambiguous "DataType | null"
// which is correct, as you haven't checked nor handled the "error".

if (result.error) {
  return null
}

// Data is strict "DataType" since you've handled the "error" above.
console.log(result.data)

It's crucial to keep the entire result of the Promise in a single variable and not destructure it. TypeScript will always keep the type of error and data as it was upon destructuring, ignoring any type guards you may perform later on.

Special thanks

• giuseppegurgone for the discussion about the original until API.

until's Issues

[Question] Why not get a promise as a param instead of a function?

Why is this better?

const [error, user] = await until(() => fetchUser(id))

instead of this?

const [error, user] = await until(fetchUser(id))

Alternative Tip/Suggestion

I saw someone using this library and it was confusing to me at first glance of what it was doing.
Then i figured: Is until needed, are there alternative solutions? And there is...

This dose not do exactly the same thing until is doing, but you won't need any try/catch or dependencies with the Settle method.

const [{status, value}] = await Promise.allSettled([fetchUser(id)])

the output is either:

{ status: "fulfilled", value: user } // or
{ status: "rejected",  reason: Error('an error') }

So the signature changes a bit. instead of checking for an error object u would have to check if status is fulfilled or rejected

-  const [error, user] = await until(() => fetchUser(id))
-
-  if (error) {
-    return handleError(error)
-  }

+  const [{status, value: user}] = await Promise.allSettled([fetchUser(id)])
+
+  if (status === 'rejected') {
+    return handleError(error)
+  }

user.password = 'abc'
await user.$save()

---

Sry if this is not an issue or bug, just wanted to share some stuff, you can close this - shares

Incorrect Types

Hi @kettanaito! 👋 Hope you are well :)

The return type doesn't agree with the null values returned here:

export const until = async <DataType = unknown, ErrorType = Error>(promise: () => Promise<DataType>): Promise<[ErrorType, DataType]> => {
  try {
    const data = await promise().catch((error) => {
      throw error
    })
    return [null, data] // 💥 Type 'null' is not assignable to type 'ErrorType'.
  } catch (error) {
    return [error, null] // 💥 Type 'null' is not assignable to type 'DataType'.
  }
}

Created a playground for this: https://www.typescriptlang.org/play?ssl=1&ssc=1&pln=10&pc=2#code/AQQwzgngdgxsBmBXWAXAlgeysZ6A2wAPACIgogAqEADgKbAC8OUA1lBgO5QA0wAogCcBGAVTqN+QkQD4AFNWEBbNGFoAuYLICUjacAAKSlbRJlKNWtK0bDGZasIBtQcNEXepcmNoBdPcABvAChgYBQBCECQ0OAYLDAUYAATMwkQDhA0RIU7Y20AOhgyGAALWVlaKQEdBj1gmJiUEuEOYErXaNCAXy1O4AFaFEQBbEcoRDw8XhTyH2iu2OKSzXaRHXqYgaGR4EdVgV5xybnuoK6gA

Question: Why use .catch on the promise

I am curious why this change was introduced.

// Original implementation  
export const until = async <DataType = unknown, ErrorType = Error>(promise: () => Promise<DataType>): Promise<[ErrorType, DataType]> => {
  try {
    const data = await promise()
    return [null, data]
  } catch (error) {
    return [error, null]
}
// Current implementation 
export const until = async <DataType = unknown, ErrorType = Error>(promise: () => Promise<DataType>): Promise<[ErrorType, DataType]> => {
  try {
   const data = await promise().catch((error) => { // .catch added
      throw error
    })
    return [null, data]
  } catch (error) {
    return [error, null]
}

Is there a benefit of calling .catch on the promise? It is my understanding that the catch block would handle throws?

Revert to array return type

The old versions of TS had trouble creating a discriminated union type out of an array tuple if you destructure it. That's not the case for the latest TS 4.9. We can use the array-based pattern again.