Batcher

Batcher: object

Defined in: Core/Batcher.ts:32

Type Declaration

make

make: <K, E, V>(options) => Batcher<K, E, V> = makeBatcher

Creates a stateful Batcher with the provided configuration options.

Type Parameters

K

K

E

E

V

V

Parameters

options

Options<K, E, V>

Returns

Batcher<K, E, V>

Example

const userBatcher = Batcher.make({
  fetch: (ids: readonly string[]) =>
    pipe(
      db.users.findMany({ where: { id: { in: ids } } }),
      Task.Result.map(Arr.indexBy((u) => u.id)),
    ),
  maxBatchSize: 100,
});

Outcome

Outcome: object

Synchronous elimination, type guards, and converters for Batcher.Outcome.

Outcome.getOrElse

getOrElse: <B>(fallback) => <E, V, K>(outcome) => B | V = getOrElseOutcome

Returns the value if BatcherOk, otherwise returns the fallback value.

Type Parameters

B

B

Parameters

fallback

() => B

Returns

<E, V, K>(outcome) => B | V

See

Batcher.Outcome.match to handle all three cases explicitly.

Example

const user = pipe(outcome, Batcher.Outcome.getOrElse(() => defaultGuestUser));

Outcome.is

is: object

Type guards for checking Batcher.Outcome variants.

Outcome.is.err

err: <E, V, K>(outcome) => outcome is Err<E> = isErr

Checks whether an outcome is a BatcherErr.

Type Parameters

E

E

V

V

K

K

Parameters

outcome

Outcome<E, V, K>

Returns

outcome is Err<E>

See

• Batcher.Outcome.is.ok to check for a resolved value.
• Batcher.Outcome.is.missing to check for an absent key.

Example

if (Batcher.Outcome.is.err(outcome)) {
  console.error(outcome.error);
}

Outcome.is.missing

missing: <E, V, K>(outcome) => outcome is Missing<K> = isMissing

Checks whether an outcome is a BatcherMissing.

Type Parameters

E

E

V

V

K

K

Parameters

outcome

Outcome<E, V, K>

Returns

outcome is Missing<K>

See

• Batcher.Outcome.is.ok to check for a resolved value.
• Batcher.Outcome.is.err to check for a query failure.

Example

if (Batcher.Outcome.is.missing(outcome)) {
  console.warn(`Key missing: ${outcome.key}`);
}

Outcome.is.ok

ok: <E, V, K>(outcome) => outcome is Ok<V> = isOk

Checks whether an outcome is a BatcherOk.

Type Parameters

E

E

V

V

K

K

Parameters

outcome

Outcome<E, V, K>

Returns

outcome is Ok<V>

See

• Batcher.Outcome.is.err to check for a query failure.
• Batcher.Outcome.is.missing to check for an absent key.

Example

if (Batcher.Outcome.is.ok(outcome)) {
  console.log(outcome.value);
}

Outcome.make

make: object

Constructors for creating Batcher.Outcome variants.

Outcome.make.err

err: <E, V, K>(error) => Outcome<E, V, K> = makeErr

Creates a BatcherErr outcome.

Type Parameters

E

E

V

V = never

K

K = never

Parameters

error

E

Returns

Outcome<E, V, K>

See

• Batcher.Outcome.make.ok to construct a successful outcome.
• Batcher.Outcome.make.missing to construct an absent key outcome.

Example

const err = Batcher.Outcome.make.err(new Error("DB connection lost"));

Outcome.make.missing

missing: <K, E, V>(key) => Outcome<E, V, K> = makeMissing

Creates a BatcherMissing outcome.

Type Parameters

K

K

E

E = never

V

V = never

Parameters

key

K

Returns

Outcome<E, V, K>

See

• Batcher.Outcome.make.ok to construct a successful outcome.
• Batcher.Outcome.make.err to construct an error outcome.

Example

const missing = Batcher.Outcome.make.missing("u_99");

Outcome.make.ok

ok: <V, E, K>(value) => Outcome<E, V, K> = makeOk

Creates a BatcherOk outcome.

Type Parameters

V

V

E

E = never

K

K = never

Parameters

value

V

Returns

Outcome<E, V, K>

See

• Batcher.Outcome.make.err to construct an error outcome.
• Batcher.Outcome.make.missing to construct an absent key outcome.

Example

const ok = Batcher.Outcome.make.ok({ id: "u1", name: "Alice" });

Outcome.map

map: <V, B>(transform) => <E, K>(outcome) => Outcome<E, B, K> = mapOutcome

Transforms the value inside a BatcherOk outcome. Leaves Missing and Err unchanged.

Type Parameters

V

V

B

B

Parameters

transform

(value) => B

Returns

<E, K>(outcome) => Outcome<E, B, K>

See

Batcher.Outcome.mapError to transform the error channel instead.

Example

const nameOutcome = pipe(outcome, Batcher.Outcome.map((user) => user.name));

Outcome.mapError

mapError: <E, F>(transform) => <V, K>(outcome) => Outcome<F, V, K> = mapErrorOutcome

Transforms the error inside a BatcherErr outcome. Leaves Ok and Missing unchanged.

Type Parameters

E

E

F

F

Parameters

transform

(error) => F

Returns

<V, K>(outcome) => Outcome<F, V, K>

See

Batcher.Outcome.map to transform the value channel instead.

Example

const mapped = pipe(outcome, Batcher.Outcome.mapError((err) => new CustomError(err)));

Outcome.match

match: <E, V, K, B>(cases) => (outcome) => B = matchOutcome

Eliminates a Batcher.Outcome by handling all three cases (ok, missing, err).

Type Parameters

E

E

V

V

K

K

B

B

Parameters

cases

err

(error) => B

missing

(key) => B

ok

(value) => B

Returns

(outcome) => B

See

Batcher.Outcome.getOrElse to extract the value with a fallback.

Example

const status = pipe(
  outcome,
  Batcher.Outcome.match({
    ok: (user) => 200,
    missing: (key) => 404,
    err: (error) => 500,
  }),
);

Outcome.to

to: object

Converters from Batcher.Outcome to standard library and native representations.

Outcome.to.Maybe

Maybe: <E, V, K>(outcome) => Maybe<V> = toMaybeOutcome

Converts a Batcher.Outcome to a Maybe, mapping BatcherOk to Some and both BatcherMissing and BatcherErr to None.

Type Parameters

E

E = never

V

V = never

K

K = never

Parameters

outcome

Outcome<E, V, K>

Returns

Maybe<V>

See

Batcher.Outcome.to.Result to convert to a fallible Result.

Example

const maybe = pipe(outcome, Batcher.Outcome.to.Maybe);

Outcome.to.nullable

nullable: <E, V, K>(outcome) => V | null = toNullableOutcome

Converts a Batcher.Outcome to a nullable value (V | null), mapping BatcherOk to V and both BatcherMissing and BatcherErr to null.

Type Parameters

E

E = never

V

V = never

K

K = never

Parameters

outcome

Outcome<E, V, K>

Returns

V | null

See

Batcher.Outcome.to.Maybe to convert to a type-safe Maybe.

Example

const userOrNull = pipe(outcome, Batcher.Outcome.to.nullable);

Outcome.to.Result

Result: <K, E2>(onMissing) => <E, V>(outcome) => Result<E2 | E, V> = toResultOutcome

Converts a Batcher.Outcome to a Result, projecting BatcherMissing into a domain error.

Type Parameters

K

K

E2

E2

Parameters

onMissing

(key) => E2

Returns

<E, V>(outcome) => Result<E2 | E, V>

See

Batcher.Outcome.to.Maybe to convert to an optional value.

Example

const res = pipe(
  outcome,
  Batcher.Outcome.to.Result((id) => ({ kind: "UserNotFound" as const, id })),
);