[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) › all

## Call Signature

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

Defined in: [packages/common/src/Task.ts:3030](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L3030)

Runs [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s until all return [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) or one returns [Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err).

Returns Ok with all values when every Task returns Ok. Stops on the first
Err; remaining running Tasks are aborted. Sequential by default; pass a
`concurrency` option to run more than one Task at a time.

Pass `{ collect: false }` when only collective success or failure matters.
The returned Task produces `void` on success and does not store the Ok
values.

With a mapping function, maps input values to Tasks before running them. The
mapper runs immediately when `all` 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.

Similar to
[Promise.all](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all),
but runs Tasks, returns [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) values, and aborts remaining Tasks on
the first Err.

### Example

```ts
import {
  assertErr,
  assertEqual,
  assertType,
  all,
  createRun,
  err,
  ok,
  type Result,
  type Task,
  type Typed,
} from "@evolu/common";

const savedUserIds: Array<string> = [];
const saveUser =
  (id: string): Task<number, SaveUserFailedError> =>
  () => {
    if (id === "missing") {
      return err({ type: "SaveUserFailed", userId: id });
    }
    savedUserIds.push(id);
    return ok(1);
  };

interface SaveUserFailedError extends Typed<"SaveUserFailed"> {
  readonly userId: string;
}

await using run = createRun();
const saveResult = await run(
  all([saveUser("user-1"), saveUser("missing"), saveUser("user-3")], {
    collect: false,
  }),
);
assertType<Result<void, SaveUserFailedError>, typeof saveResult>();
assertErr(saveResult, {
  type: "SaveUserFailed",
  userId: "missing",
});
assertEqual(savedUserIds, ["user-1"]);
```

## Call Signature

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

Defined in: [packages/common/src/Task.ts:3036](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L3036)

Runs a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) record without collecting its [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) values.

## Call Signature

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

Defined in: [packages/common/src/Task.ts:3078](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L3078)

Runs a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) array and preserves its shape.

### Example

```ts
import {
  assertOk,
  assertType,
  all,
  createRun,
  ok,
  type Result,
  type Task,
} from "@evolu/common";

interface User {
  readonly id: string;
}

interface Post {
  readonly id: string;
}

const fetchUser: Task<User> = () => ok({ id: "user-1" });
const fetchPosts: Task<ReadonlyArray<Post>> = () => ok([{ id: "post-1" }]);

await using run = createRun();
const dashboard = await run(all([fetchUser, fetchPosts]));
assertType<Result<readonly [User, ReadonlyArray<Post>]>, typeof dashboard>();
assertOk(dashboard, [{ id: "user-1" }, [{ id: "post-1" }]]);
```

## Call Signature

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

Defined in: [packages/common/src/Task.ts:3128](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L3128)

Runs a [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task) record and preserves its keys.

### Example

```ts
import {
  assertOk,
  assertType,
  all,
  createRun,
  ok,
  type Result,
  type Task,
} from "@evolu/common";

interface User {
  readonly id: string;
}

interface Post {
  readonly id: string;
}

const fetchUser: Task<User> = () => ok({ id: "user-1" });
const fetchPosts: Task<ReadonlyArray<Post>> = () => ok([{ id: "post-1" }]);

await using run = createRun();
const result = await run(all({ user: fetchUser, posts: fetchPosts }));

assertType<
  Result<{ readonly user: User; readonly posts: ReadonlyArray<Post> }>,
  typeof result
>();
assertOk(result, {
  user: { id: "user-1" },
  posts: [{ id: "post-1" }],
});
```

## Call Signature

```ts
function all<TValues, TTask>(
  values: TValues,
  fn: (value: TValues[number], index: number) => TTask,
  options: AllOptions,
): Task<
  void,
  InferTaskErr<TTask>,
  ParameterIntersection<
    TTask extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;
```

Defined in: [packages/common/src/Task.ts:3138](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L3138)

Maps an array to [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s without collecting their [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) values.

## Call Signature

```ts
function all<TValues, TTask>(
  values: TValues,
  fn: (value: TValues[keyof TValues], key: keyof TValues) => TTask,
  options: AllOptions,
): Task<
  void,
  InferTaskErr<TTask>,
  ParameterIntersection<
    TTask extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;
```

Defined in: [packages/common/src/Task.ts:3148](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L3148)

Maps record values to [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s without collecting their [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) values.

## Call Signature

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

Defined in: [packages/common/src/Task.ts:3201](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L3201)

Maps an array to [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s and collects their [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) values in the same
shape.

### Example

```ts
import {
  assertEqual,
  assertOk,
  assertType,
  all,
  createRun,
  ok,
  type Result,
  type Task,
} from "@evolu/common";

interface User {
  readonly id: string;
}

const loadUser =
  (id: string): Task<User> =>
  () =>
    ok({ id });

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

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

await using run = createRun();
const result = await run(loadUsers);
assertType<Result<readonly [User, User]>, typeof result>();
assertOk(result, [{ id: "user-1" }, { id: "user-2" }]);
```

## Call Signature

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

Defined in: [packages/common/src/Task.ts:3265](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Task.ts#L3265)

Maps record values to [Task](https://evolu.dev/docs/api-reference/common/Task/type-aliases/Task)s and preserves the record's keys.

### Example

```ts
import {
  assertEqual,
  assertOk,
  assertType,
  all,
  createRun,
  ok,
  type Result,
  type Task,
} from "@evolu/common";

interface User {
  readonly id: string;
}

const loadUser =
  (id: string): Task<User> =>
  () =>
    ok({ id });

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

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

await using run = createRun();
const result = await run(loadUsersByRole);
assertType<
  Result<{ readonly admin: User; readonly reviewer: User }>,
  typeof result
>();
assertOk(result, {
  admin: { id: "user-1" },
  reviewer: { id: "user-2" },
});
```