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

## Call Signature

```ts
function allSettled<TTasks>(
  tasks: TTasks,
  options?: TaskCollectionOptions,
): Task<
  InferTasksSettled<TTasks>,
  never,
  ParameterIntersection<
    TTasks[number] extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;
```

Defined in: [packages/common/src/Task.ts:3275](https://github.com/evoluhq/evolu/blob/49ea8ca499566aba270f8cb601e7f49aa62320f8/packages/common/src/Task.ts#L3275)

Runs all Tasks and returns every Task [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result).

Unlike [all](https://evolu.dev/docs/api-reference/common/Task/functions/all), [Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err) Results do not stop later Tasks.

With a mapping function, maps input values to Tasks before running them. The
mapper runs immediately when `allSettled` is called, before the returned Task
starts. Array mappers receive `(value, index)`. Record mappers receive
`(value, key)`. Mapper defects happen at construction time, so keep mappers
pure and cheap.

Sequential by default; pass a `concurrency` option to run more than one Task
at a time.

Similar to
[Promise.allSettled](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled),
but runs Tasks and returns Result values.

### Example

```ts
import {
  allSettled,
  createRun,
  err,
  ok,
  type Result,
  type Task,
} from "@evolu/common";

interface LoadError {
  readonly type: "LoadError";
}

const loadProfile: Task<string, LoadError> = () => err({ type: "LoadError" });
let activityLoaded = false;
const loadActivity: Task<ReadonlyArray<string>> = () => {
  activityLoaded = true;
  return ok(["signed-in"]);
};

await using run = createRun();
const results = await run(allSettled([loadProfile, loadActivity]));
expectTypeOf(results).toEqualTypeOf<
  Result<readonly [Result<string, LoadError>, Result<ReadonlyArray<string>>]>
>();
expectOk(results, [
  { ok: false, error: { type: "LoadError" } },
  { ok: true, value: ["signed-in"] },
]);
// Unlike all, a later Task still runs after an Err.
expect(activityLoaded).toBe(true);
```

## Call Signature

```ts
function allSettled<TTasks>(
  tasks: TTasks,
  options?: TaskCollectionOptions,
): Task<
  InferTasksSettled<TTasks>,
  never,
  ParameterIntersection<
    TTasks[keyof TTasks] extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;
```

Defined in: [packages/common/src/Task.ts:3322](https://github.com/evoluhq/evolu/blob/49ea8ca499566aba270f8cb601e7f49aa62320f8/packages/common/src/Task.ts#L3322)

Runs a Task record and preserves its keys.

### Example

```ts
import {
  allSettled,
  createRun,
  err,
  ok,
  type Result,
  type Task,
} from "@evolu/common";

interface User {
  readonly id: string;
}
interface LoadError {
  readonly type: "LoadError";
}
const fetchUser: Task<User> = () => ok({ id: "user-1" });
const fetchProfile: Task<string, LoadError> = () => err({ type: "LoadError" });

await using run = createRun();
const results = await run(
  allSettled({ user: fetchUser, profile: fetchProfile }),
);

expectTypeOf(results).toEqualTypeOf<
  Result<{
    readonly user: Result<User>;
    readonly profile: Result<string, LoadError>;
  }>
>();
expectOk(results, {
  user: { ok: true, value: { id: "user-1" } },
  profile: { ok: false, error: { type: "LoadError" } },
});
```

## Call Signature

```ts
function allSettled<TValues, TTask>(
  values: TValues,
  fn: (value: TValues[number], index: number) => TTask,
  options?: TaskCollectionOptions,
): Task<
  {
    readonly [K in string | number | symbol]: Result<
      InferTaskOk<TTask>,
      InferTaskErr<TTask>
    >;
  },
  never,
  ParameterIntersection<
    TTask extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;
```

Defined in: [packages/common/src/Task.ts:3374](https://github.com/evoluhq/evolu/blob/49ea8ca499566aba270f8cb601e7f49aa62320f8/packages/common/src/Task.ts#L3374)

Maps an array to Tasks and preserves its shape.

### Example

```ts
import {
  allSettled,
  createRun,
  err,
  ok,
  type Result,
  type Task,
} from "@evolu/common";

interface User {
  readonly id: string;
}
interface LoadError {
  readonly type: "LoadError";
}
const loadUser =
  (id: string): Task<User, LoadError> =>
  () =>
    id === "missing" ? err({ type: "LoadError" }) : ok({ id });

const userIds = ["user-1", "missing"] as const;
const indexes: Array<number> = [];
const loadUsers = allSettled(userIds, (id, index) => {
  indexes.push(index);
  return loadUser(id);
});

// Mapping is eager: it happens before the returned Task starts.
expect(indexes).toEqual([0, 1]);

await using run = createRun();
const results = await run(loadUsers);
expectTypeOf(results).toEqualTypeOf<
  Result<readonly [Result<User, LoadError>, Result<User, LoadError>]>
>();
expectOk(results, [
  { ok: true, value: { id: "user-1" } },
  { ok: false, error: { type: "LoadError" } },
]);
```

## Call Signature

```ts
function allSettled<TValues, TTask>(
  values: TValues,
  fn: (value: TValues[keyof TValues], key: keyof TValues) => TTask,
  options?: TaskCollectionOptions,
): Task<
  {
    readonly [K in string | number | symbol]: Result<
      InferTaskOk<TTask>,
      InferTaskErr<TTask>
    >;
  },
  never,
  ParameterIntersection<
    TTask extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;
```

Defined in: [packages/common/src/Task.ts:3442](https://github.com/evoluhq/evolu/blob/49ea8ca499566aba270f8cb601e7f49aa62320f8/packages/common/src/Task.ts#L3442)

Maps record values to Tasks and preserves its keys.

### Example

```ts
import {
  allSettled,
  createRun,
  err,
  ok,
  type Result,
  type Task,
} from "@evolu/common";

interface User {
  readonly id: string;
}
interface LoadError {
  readonly type: "LoadError";
}
const loadUser =
  (id: string): Task<User, LoadError> =>
  () =>
    id === "missing" ? err({ type: "LoadError" }) : ok({ id });

const userIdsByRole = { admin: "user-1", reviewer: "missing" } as const;
const roles: Array<keyof typeof userIdsByRole> = [];
const loadUsersByRole = allSettled(userIdsByRole, (id, role) => {
  roles.push(role);
  return loadUser(id);
});

// Mapping is eager: it happens before the returned Task starts.
expect(roles).toEqual(["admin", "reviewer"]);

await using run = createRun();
const results = await run(loadUsersByRole);
expectTypeOf(results).toEqualTypeOf<
  Result<{
    readonly admin: Result<User, LoadError>;
    readonly reviewer: Result<User, LoadError>;
  }>
>();
expectOk(results, {
  admin: { ok: true, value: { id: "user-1" } },
  reviewer: { ok: false, error: { type: "LoadError" } },
});
```