Skip to content

Commit 49f8ed7

Browse files
committed
fix(shared): require handled errors in keyed workers
1 parent 1e0cc20 commit 49f8ed7

2 files changed

Lines changed: 49 additions & 3 deletions

File tree

‎packages/shared/src/DrainableWorker.test.ts‎

Lines changed: 44 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
import { it } from "@effect/vitest";
2-
import { describe, expect } from "vite-plus/test";
2+
import { describe, expect, expectTypeOf } from "vite-plus/test";
33
import * as Deferred from "effect/Deferred";
44
import * as Effect from "effect/Effect";
55

@@ -57,6 +57,49 @@ describe("makeDrainableWorker", () => {
5757
});
5858

5959
describe("makeKeyedDrainableWorker", () => {
60+
it("requires callers to handle typed failures", () => {
61+
type Process = Parameters<typeof makeKeyedDrainableWorker>[1];
62+
expectTypeOf<Effect.Error<ReturnType<Process>>>().toEqualTypeOf<never>();
63+
});
64+
65+
it.live("drains queued work after the caller handles an item failure", () =>
66+
Effect.scoped(
67+
Effect.gen(function* () {
68+
const processed: string[] = [];
69+
const handled: string[] = [];
70+
const firstStarted = yield* Deferred.make<void>();
71+
const releaseFirst = yield* Deferred.make<void>();
72+
const worker = yield* makeKeyedDrainableWorker(
73+
(_item: string) => "lane",
74+
(item) =>
75+
Effect.gen(function* () {
76+
if (item === "first") {
77+
yield* Deferred.succeed(firstStarted, undefined);
78+
yield* Deferred.await(releaseFirst);
79+
return yield* Effect.fail("item failed");
80+
}
81+
processed.push(item);
82+
}).pipe(
83+
Effect.catch((error) =>
84+
Effect.sync(() => {
85+
handled.push(error);
86+
}),
87+
),
88+
),
89+
);
90+
91+
yield* worker.enqueue("first");
92+
yield* Deferred.await(firstStarted);
93+
yield* worker.enqueue("second");
94+
yield* Deferred.succeed(releaseFirst, undefined);
95+
yield* worker.drain;
96+
97+
expect(handled).toEqual(["item failed"]);
98+
expect(processed).toEqual(["second"]);
99+
}),
100+
),
101+
);
102+
60103
it.live("runs different keys independently while preserving each key's FIFO", () =>
61104
Effect.scoped(
62105
Effect.gen(function* () {

‎packages/shared/src/DrainableWorker.ts‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -45,13 +45,16 @@ export interface DrainableWorker<A> {
4545
* version-bumped lanes). Idle lanes are
4646
* removed once drained so key cardinality stays bounded.
4747
*
48+
* Callers must handle processing failures before returning: an unhandled failure
49+
* stops the lane and leaves queued items undrained.
50+
*
4851
* @param keyOf - Derives the lane key for an item.
4952
* @param process - The effect to run for each queued item.
5053
* @returns A `DrainableWorker` with `enqueue` and `drain`.
5154
*/
52-
export const makeKeyedDrainableWorker = <A, K, E, R>(
55+
export const makeKeyedDrainableWorker = <A, K, R>(
5356
keyOf: (item: A) => K,
54-
process: (item: A) => Effect.Effect<void, E, R>,
57+
process: (item: A) => Effect.Effect<void, never, R>,
5558
): Effect.Effect<DrainableWorker<A>, never, Scope.Scope | R> =>
5659
Effect.gen(function* () {
5760
const context = yield* Effect.context<R>();

0 commit comments

Comments
 (0)