[API reference](https://evolu.dev/docs/api-reference) › [@evolu/common](https://evolu.dev/docs/api-reference/common) › [Result](https://evolu.dev/docs/api-reference/common/Result) › tryAsync

## Call Signature

```ts
function tryAsync<T>(
  promiseThunk: Thunk<Awaitable<T>>,
): Promise<Result<T, unknown>>;
```

Defined in: [packages/common/src/Result.ts:703](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L703)

Wraps an async function that may throw or reject, returning a [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result).

When provided, `mapError` converts the caught `unknown` value into a typed
domain error.

Some async APIs throw or reject for both recoverable and unrecoverable
errors. In that case, convert only the errors the caller can recover from and
rethrow the rest. The `tryAsync` error mapper leaves rethrown values as
Promise rejections instead of converting them to [Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err).

### Example

```ts
import {
  assert,
  assertErr,
  assertEqual,
  assertOk,
  assertType,
  tryAsync,
  type Result,
  type Typed,
} from "@evolu/common";

class LegacySeatUnavailableError extends Error {}

const legacyReserveSeat = (seat: string): Promise<void> => {
  if (seat === "A1") {
    return Promise.reject(new LegacySeatUnavailableError());
  }
  if (seat === "B1") return Promise.reject(new Error("Database error"));
  return Promise.resolve();
};

const reserveSeat = (
  seat: string,
): Promise<Result<void, SeatUnavailableError>> =>
  tryAsync(
    () => legacyReserveSeat(seat),
    (error) => {
      if (error instanceof LegacySeatUnavailableError) {
        return { type: "SeatUnavailable", seat };
      }
      throw error;
    },
  );

interface SeatUnavailableError extends Typed<"SeatUnavailable"> {
  readonly seat: string;
}

const result = await reserveSeat("B2");
assertType<Result<void, SeatUnavailableError>, typeof result>();
assertOk(result, undefined);
assertErr(await reserveSeat("A1"), {
  type: "SeatUnavailable",
  seat: "A1",
});
const databaseError = await tryAsync(() => reserveSeat("B1"));
assertErr(databaseError);
assert(databaseError.error instanceof Error, "Expected an Error.");
assertEqual(databaseError.error.message, "Database error");
```

## Call Signature

```ts
function tryAsync<T, E>(
  promiseThunk: Thunk<Awaitable<T>>,
  mapError: (error: unknown) => E,
): Promise<Result<T, E>>;
```

Defined in: [packages/common/src/Result.ts:708](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L708)

Maps thrown or rejected values to a typed error.