effect-cqrs 0.0.0-stage → 0.1.0

package/src/Fixture.ts

@@ -0,0 +1,213 @@
+/**
+ * Tests an aggregate in isolation: given these events, when this command runs,
+ * what happens? The moleculer-cqrs `CQRSFixture`, as a chain that runs when it
+ * is yielded:
+ *
+ * ```ts
+ * yield* Fixture.make(Todo)
+ *   .givenEvents([created])
+ *   .when("deleteTodo", { message: "Done" })
+ *   .expectEvent("TodoDeleted")
+ *   .inspectState((state) => assert.strictEqual(state.status, "deleted"))
+ * ```
+ *
+ * Commands run through the real {@link AggregateService} on an in-memory store,
+ * so payload validation and event encoding are exercised too.
+ */
+import { Effect, Effectable, Schema } from "effect"
+import type * as Aggregate from "./Aggregate.ts"
+import * as AggregateService from "./AggregateService.ts"
+import { EventStore, makeMemory } from "./EventStore.ts"
+
+/** Raised as a defect, so a command's error channel only holds what the command can do. */
+export class ExpectationFailed extends Schema.TaggedError<ExpectationFailed>()("ExpectationFailed", {
+  message: Schema.String,
+  expected: Schema.Unknown,
+  actual: Schema.Unknown
+}) {}
+
+export interface Outcome<A extends Aggregate.Any> {
+  readonly events: ReadonlyArray<Aggregate.Event<A>>
+  readonly state: Aggregate.State<A>
+  readonly version: number
+  /** Continues from here, with this outcome's events as the new history. */
+  readonly fixture: Fixture<A>
+}
+
+/** An event to compare with, or only its tag when the rest doesn't matter. */
+export type ExpectedEvent<A extends Aggregate.Any> = Aggregate.Event<A> | Aggregate.Event<A>["_tag"]
+
+/**
+ * The steps so far. Nothing runs until it is yielded or run as an Effect, which
+ * produces the {@link Outcome} of the last command.
+ */
+export interface Scenario<A extends Aggregate.Any, E, R> extends Effect.Effect<Outcome<A>, E, R> {
+  /** Runs another command on top of the previous one. */
+  when<K extends Aggregate.CommandName<A>>(
+    command: K,
+    payload: Aggregate.Payload<A, K>
+  ): Scenario<A, E | Aggregate.CommandError<A, K> | AggregateService.CommandFailure, R | Aggregate.Context<A>>
+  /** Runs a command that is expected to fail and returns the error. Dies if it succeeds. */
+  whenFails<K extends Aggregate.CommandName<A>>(
+    command: K,
+    payload: Aggregate.Payload<A, K>
+  ): Effect.Effect<Aggregate.CommandError<A, K> | AggregateService.CommandFailure, E, R | Aggregate.Context<A>>
+  /** Expects the last command to have emitted exactly this event. */
+  expectEvent(event: ExpectedEvent<A>): Scenario<A, E, R>
+  /** Expects the last command to have emitted exactly these events, in order. */
+  expectEvents(events: ReadonlyArray<ExpectedEvent<A>>): Scenario<A, E, R>
+  /** Passes the current state to a callback, which throws to fail the test. */
+  inspectState(check: (state: Aggregate.State<A>) => void): Scenario<A, E, R>
+}
+
+export interface Fixture<A extends Aggregate.Any> {
+  /** Replaces the history the next command runs against. */
+  given(events: ReadonlyArray<Aggregate.Event<A>>): Fixture<A>
+  /** Like `given`, starting from an empty history by default and optionally switching aggregate id. */
+  givenEvents(events?: ReadonlyArray<Aggregate.Event<A>>, aggregateId?: string): Fixture<A>
+  /** The state after the given events, without running a command. */
+  readonly state: Effect.Effect<Aggregate.State<A>, AggregateService.ReadError, Aggregate.Context<A>>
+  /** Passes the state after the given events to a callback, which throws to fail the test. */
+  inspectState(
+    check: (state: Aggregate.State<A>) => void
+  ): Scenario<A, AggregateService.ReadError, Aggregate.Context<A>>
+  when<K extends Aggregate.CommandName<A>>(
+    command: K,
+    payload: Aggregate.Payload<A, K>
+  ): Scenario<A, Aggregate.CommandError<A, K> | AggregateService.CommandFailure, Aggregate.Context<A>>
+  /** Runs a command that is expected to fail and returns the error. Dies if it succeeds. */
+  whenFails<K extends Aggregate.CommandName<A>>(
+    command: K,
+    payload: Aggregate.Payload<A, K>
+  ): Effect.Effect<Aggregate.CommandError<A, K> | AggregateService.CommandFailure, never, Aggregate.Context<A>>
+}
+
+class ScenarioImpl<A extends Aggregate.Any, E, R> extends Effectable.Class<Outcome<A>, E, R>
+  implements Scenario<A, E, R>
+{
+  readonly aggregate: A
+  readonly run: Effect.Effect<Outcome<A>, E, R>
+
+  constructor(aggregate: A, run: Effect.Effect<Outcome<A>, E, R>) {
+    super()
+    this.aggregate = aggregate
+    this.run = run
+  }
+
+  asEffect() {
+    return this.run
+  }
+
+  when<K extends Aggregate.CommandName<A>>(command: K, payload: Aggregate.Payload<A, K>) {
+    return new ScenarioImpl(
+      this.aggregate,
+      Effect.flatMap(this.run, (outcome) => outcome.fixture.when(command, payload))
+    )
+  }
+
+  whenFails<K extends Aggregate.CommandName<A>>(command: K, payload: Aggregate.Payload<A, K>) {
+    return Effect.flatMap(this.run, (outcome) => outcome.fixture.whenFails(command, payload))
+  }
+
+  expectEvent(event: ExpectedEvent<A>) {
+    return this.expectEvents([event])
+  }
+
+  expectEvents(expected: ReadonlyArray<ExpectedEvent<A>>) {
+    const isSameEvent = Schema.toEquivalence<unknown>(this.aggregate.events)
+    const matches = (want: ExpectedEvent<A>, event: Aggregate.Event<A>) =>
+      typeof want === "string" ? event._tag === want : isSameEvent(want, event)
+
+    return new ScenarioImpl(
+      this.aggregate,
+      Effect.tap(this.run, ({ events }) =>
+        events.length === expected.length && expected.every((want, index) => matches(want, events[index]))
+          ? Effect.void
+          : Effect.die(
+            new ExpectationFailed({
+              message: "The command did not emit the expected events",
+              expected,
+              actual: events
+            })
+          ))
+    )
+  }
+
+  inspectState(check: (state: Aggregate.State<A>) => void) {
+    return new ScenarioImpl(
+      this.aggregate,
+      Effect.tap(this.run, ({ state }) => Effect.sync(() => check(state)))
+    )
+  }
+}
+
+export const make = <A extends Aggregate.Any>(
+  aggregate: A,
+  options?: {
+    readonly aggregateId?: string
+    readonly events?: ReadonlyArray<Aggregate.Event<A>>
+  }
+): Fixture<A> => {
+  const aggregateId = options?.aggregateId ?? "fixture-id"
+  const history = options?.events ?? []
+  const encodeEvent = AggregateService.makeEventEncoder(aggregate)
+
+  const seeded = Effect.gen(function*() {
+    const store = yield* makeMemory
+    if (history.length > 0) {
+      yield* store.append({
+        aggregateName: aggregate.name,
+        aggregateId,
+        expectedVersion: 0,
+        events: yield* Effect.forEach(history, encodeEvent)
+      })
+    }
+    const service = yield* AggregateService.make(aggregate).pipe(Effect.provideService(EventStore, store))
+    return service
+  }).pipe(
+    // A store with nothing but memory behind it can't fail, and a history that
+    // doesn't fit a fresh stream is a mistake in the test.
+    Effect.orDie
+  )
+
+  const state = Effect.flatMap(seeded, (service) => service.readModel(aggregateId))
+
+  const when = <K extends Aggregate.CommandName<A>>(command: K, payload: Aggregate.Payload<A, K>) =>
+    new ScenarioImpl(
+      aggregate,
+      Effect.gen(function*() {
+        const service = yield* seeded
+        const result = yield* service.commands[command](aggregateId, payload)
+        return {
+          events: result.events,
+          state: yield* service.readModel(aggregateId),
+          version: result.version,
+          fixture: make(aggregate, { aggregateId, events: [...history, ...result.events] })
+        } satisfies Outcome<A>
+      })
+    )
+
+  const fixture: Fixture<A> = {
+    given: (events) => make(aggregate, { aggregateId, events }),
+    givenEvents: (events = [], id = aggregateId) => make(aggregate, { aggregateId: id, events }),
+    state,
+    inspectState: (check) =>
+      new ScenarioImpl(
+        aggregate,
+        Effect.map(state, (current): Outcome<A> => ({
+          events: [],
+          state: current,
+          version: history.length,
+          fixture
+        }))
+      ).inspectState(check),
+    when,
+    whenFails: (command, payload) =>
+      when(command, payload).pipe(
+        Effect.flip,
+        Effect.catch(() => Effect.die(new Error(`Expected command "${command}" to fail, but it succeeded`)))
+      )
+  }
+
+  return fixture
+}

package/src/PostgresEventStore.ts

@@ -0,0 +1,188 @@
+/**
+ * Durable storage on PostgreSQL, through any `effect/sql` PostgreSQL driver.
+ *
+ * A sequence can't number events here. Transactions commit in a different order from
+ * the one they drew their numbers in, so a view model that has read up to 6 would
+ * never come back for a 5 that commits later. Positions come from a counter row
+ * instead, which an append holds until it commits: writers wait for each other at
+ * that one step, and positions follow commit order with no gaps.
+ *
+ * The tables are created on startup.
+ */
+import { Array as Arr, Clock, DateTime, Effect, Layer, Schema } from "effect"
+import { SqlClient, type SqlError } from "effect/sql"
+import { Checkpoints } from "./Checkpoints.ts"
+import * as EventStore from "./EventStore.ts"
+
+export interface Options {
+  readonly eventsTable?: string
+  readonly checkpointsTable?: string
+}
+
+const decodeRows = Schema.decodeUnknownEffect(Schema.Array(EventStore.StoredEvent))
+
+const storeError = (operation: string) => (cause: unknown) => new EventStore.EventStoreError({ operation, cause })
+
+const isUniqueViolation = (error: SqlError.SqlError) => error.reason._tag === "UniqueViolation"
+
+// The client binds at most 32,767 parameters to a statement, and each row uses 7.
+const rowsPerInsert = 4_000
+
+export const make = Effect.fnUntraced(function*(options?: Options) {
+  const sql = yield* SqlClient.SqlClient
+  const prefix = options?.eventsTable ?? "cqrs_events"
+  const events = sql(prefix)
+  const counter = sql(`${prefix}_head`)
+
+  const initialize = Effect.gen(function*() {
+    yield* sql`
+      CREATE TABLE IF NOT EXISTS ${events} (
+        position BIGINT PRIMARY KEY,
+        aggregate_name TEXT NOT NULL,
+        aggregate_id TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        type TEXT NOT NULL,
+        payload JSONB NOT NULL,
+        "timestamp" BIGINT NOT NULL,
+        UNIQUE (aggregate_name, aggregate_id, version)
+      )
+    `
+    yield* sql`CREATE INDEX IF NOT EXISTS ${sql(`${prefix}_type_idx`)} ON ${events} (type, position)`
+    yield* sql`
+      CREATE TABLE IF NOT EXISTS ${counter} (
+        only_row BOOLEAN PRIMARY KEY DEFAULT TRUE CHECK (only_row),
+        position BIGINT NOT NULL
+      )
+    `
+    yield* sql`INSERT INTO ${counter} (position) VALUES (0) ON CONFLICT DO NOTHING`
+  })
+  yield* initialize.pipe(Effect.mapError(storeError("initialize")))
+
+  const columns = sql.literal(`
+    position::float8 AS position,
+    aggregate_name AS "aggregateName",
+    aggregate_id AS "aggregateId",
+    version,
+    type,
+    payload,
+    "timestamp"::float8 AS "timestamp"
+  `)
+
+  const append = (input: EventStore.AppendInput) => {
+    const conflict = new EventStore.ConcurrencyConflict({
+      aggregateName: input.aggregateName,
+      aggregateId: input.aggregateId,
+      expectedVersion: input.expectedVersion
+    })
+    return Effect.gen(function*() {
+      const [current] = yield* sql<{ readonly version: number }>`
+        SELECT COALESCE(MAX(version), 0) AS version FROM ${events}
+        WHERE aggregate_name = ${input.aggregateName} AND aggregate_id = ${input.aggregateId}
+      `
+      if (current?.version !== input.expectedVersion) {
+        return yield* conflict
+      }
+      const timestamp = yield* Clock.currentTimeMillis
+      const [head] = yield* sql<{ readonly position: number }>`
+        UPDATE ${counter} SET position = position + ${input.events.length} RETURNING position::float8 AS position
+      `
+      const first = head!.position - input.events.length + 1
+      const stored = input.events.map((event, index): EventStore.StoredEvent => ({
+        position: first + index,
+        aggregateName: input.aggregateName,
+        aggregateId: input.aggregateId,
+        version: input.expectedVersion + index + 1,
+        type: event.type,
+        payload: event.payload,
+        timestamp: DateTime.makeUnsafe(timestamp)
+      }))
+      const rows = stored.map((event) => ({
+        position: event.position,
+        aggregate_name: event.aggregateName,
+        aggregate_id: event.aggregateId,
+        version: event.version,
+        type: event.type,
+        payload: JSON.stringify(event.payload),
+        timestamp
+      }))
+      yield* Effect.forEach(
+        Arr.chunksOf(rows, rowsPerInsert),
+        (chunk) => sql`INSERT INTO ${events} ${sql.insert(chunk)}`,
+        { discard: true }
+      )
+      return stored
+    }).pipe(
+      sql.withTransaction,
+      // The version check can't see a writer that hasn't committed, but the UNIQUE
+      // constraint can. Rolling back gives the position back, so that leaves no gap.
+      Effect.catchTag("SqlError", (error) => Effect.fail(isUniqueViolation(error) ? conflict : storeError("append")(error)))
+    )
+  }
+
+  const readBatch = (filter: EventStore.EventFilter, afterPosition: number, limit: number) => {
+    const oneStream = EventStore.isOneStream(filter)
+    const clauses = [
+      sql`${events}.position > ${afterPosition}`,
+      ...(oneStream ? [sql`version > ${filter.afterVersion ?? 0}`] : []),
+      ...(filter.aggregateNames === undefined ? [] : [sql.in("aggregate_name", filter.aggregateNames)]),
+      ...(filter.aggregateIds === undefined ? [] : [sql.in("aggregate_id", filter.aggregateIds)]),
+      ...(filter.eventTypes === undefined ? [] : [sql.in("type", filter.eventTypes)]),
+      ...(filter.startTime === undefined ? [] : [sql`"timestamp" >= ${DateTime.toEpochMillis(filter.startTime)}`]),
+      ...(filter.finishTime === undefined ? [] : [sql`"timestamp" < ${DateTime.toEpochMillis(filter.finishTime)}`])
+    ]
+    // Inside a stream versions follow positions, and ordering by them keeps to the
+    // stream's index. With `LIMIT` the planner would otherwise walk the primary key,
+    // through every later event of the log, looking for a stream with nothing new.
+    // `position` alone would mean the converted column above, which has no index.
+    const order = oneStream ? sql`version` : sql`${events}.position`
+    return sql`SELECT ${columns} FROM ${events} WHERE ${sql.and(clauses)} ORDER BY ${order} LIMIT ${limit}`.pipe(
+      Effect.flatMap(decodeRows),
+      Effect.mapError(storeError("read"))
+    )
+  }
+
+  const head = sql<{ readonly position: number }>`SELECT position::float8 AS position FROM ${counter}`.pipe(
+    Effect.map(([row]) => row?.position ?? 0),
+    Effect.mapError(storeError("head"))
+  )
+
+  return yield* EventStore.make({ append, readBatch, head })
+})
+
+export const layer = (options?: Options): Layer.Layer<EventStore.EventStore, EventStore.EventStoreError, SqlClient.SqlClient> =>
+  Layer.effect(EventStore.EventStore, make(options))
+
+/** Keeps checkpoints in the same database, for view models that are durable too. */
+export const layerCheckpoints = (options?: Options): Layer.Layer<Checkpoints, EventStore.EventStoreError, SqlClient.SqlClient> =>
+  Layer.effect(
+    Checkpoints,
+    Effect.gen(function*() {
+      const sql = yield* SqlClient.SqlClient
+      const table = sql(options?.checkpointsTable ?? "cqrs_checkpoints")
+
+      yield* sql`
+        CREATE TABLE IF NOT EXISTS ${table} (
+          view_model TEXT PRIMARY KEY,
+          position BIGINT NOT NULL
+        )
+      `.pipe(Effect.mapError(storeError("initialize")))
+
+      return Checkpoints.of({
+        get: (viewModel) =>
+          sql<{ readonly position: number }>`
+            SELECT position::float8 AS position FROM ${table} WHERE view_model = ${viewModel}
+          `.pipe(
+            Effect.map(([row]) => row?.position ?? 0),
+            Effect.mapError(storeError("checkpoint"))
+          ),
+        set: (viewModel, position) =>
+          sql`
+            INSERT INTO ${table} (view_model, position) VALUES (${viewModel}, ${position})
+            ON CONFLICT (view_model) DO UPDATE SET position = excluded.position
+          `.pipe(
+            Effect.asVoid,
+            Effect.mapError(storeError("checkpoint"))
+          )
+      })
+    })
+  )

package/src/SqliteEventStore.ts

@@ -0,0 +1,166 @@
+/**
+ * Durable storage on SQLite, through any `effect/sql` SQLite driver.
+ *
+ * The tables are created on startup. The schema relies on SQLite's single writer
+ * for positions to follow commit order, so it is not portable to other databases.
+ */
+import { Clock, DateTime, Effect, Layer, Schema } from "effect"
+import { SqlClient, type SqlError } from "effect/sql"
+import { Checkpoints } from "./Checkpoints.ts"
+import * as EventStore from "./EventStore.ts"
+
+export interface Options {
+  readonly eventsTable?: string
+  readonly checkpointsTable?: string
+}
+
+const EventRow = Schema.Struct({
+  ...EventStore.StoredEvent.fields,
+  payload: Schema.fromJsonString(Schema.Json)
+})
+
+const decodeRows = Schema.decodeUnknownEffect(Schema.Array(EventRow))
+
+const storeError = (operation: string) => (cause: unknown) => new EventStore.EventStoreError({ operation, cause })
+
+const isUniqueViolation = (error: SqlError.SqlError) => error.reason._tag === "UniqueViolation"
+
+export const make = Effect.fnUntraced(function*(options?: Options) {
+  const sql = yield* SqlClient.SqlClient
+  const events = sql(options?.eventsTable ?? "cqrs_events")
+  const indexPrefix = options?.eventsTable ?? "cqrs_events"
+
+  yield* sql`
+    CREATE TABLE IF NOT EXISTS ${events} (
+      position INTEGER PRIMARY KEY AUTOINCREMENT,
+      aggregate_name TEXT NOT NULL,
+      aggregate_id TEXT NOT NULL,
+      version INTEGER NOT NULL,
+      type TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      timestamp INTEGER NOT NULL,
+      UNIQUE (aggregate_name, aggregate_id, version)
+    )
+  `.pipe(Effect.mapError(storeError("initialize")))
+  yield* sql`
+    CREATE INDEX IF NOT EXISTS ${sql(`${indexPrefix}_type_idx`)} ON ${events} (type, position)
+  `.pipe(Effect.mapError(storeError("initialize")))
+
+  const columns = sql.literal(`
+    position,
+    aggregate_name AS "aggregateName",
+    aggregate_id AS "aggregateId",
+    version,
+    type,
+    payload,
+    timestamp
+  `)
+
+  const append = (input: EventStore.AppendInput) => {
+    const conflict = new EventStore.ConcurrencyConflict({
+      aggregateName: input.aggregateName,
+      aggregateId: input.aggregateId,
+      expectedVersion: input.expectedVersion
+    })
+    return Effect.gen(function*() {
+      const [current] = yield* sql<{ readonly version: number }>`
+        SELECT COALESCE(MAX(version), 0) AS version FROM ${events}
+        WHERE aggregate_name = ${input.aggregateName} AND aggregate_id = ${input.aggregateId}
+      `
+      if (current?.version !== input.expectedVersion) {
+        return yield* conflict
+      }
+      const timestamp = yield* Clock.currentTimeMillis
+      return yield* Effect.forEach(input.events, (event, index) =>
+        sql<{ readonly position: number }>`
+          INSERT INTO ${events} (aggregate_name, aggregate_id, version, type, payload, timestamp)
+          VALUES (
+            ${input.aggregateName},
+            ${input.aggregateId},
+            ${input.expectedVersion + index + 1},
+            ${event.type},
+            ${JSON.stringify(event.payload)},
+            ${timestamp}
+          )
+          RETURNING position
+        `.pipe(
+          Effect.map(([row]): EventStore.StoredEvent => ({
+            position: row!.position,
+            aggregateName: input.aggregateName,
+            aggregateId: input.aggregateId,
+            version: input.expectedVersion + index + 1,
+            type: event.type,
+            payload: event.payload,
+            timestamp: DateTime.makeUnsafe(timestamp)
+          }))
+        ))
+    }).pipe(
+      sql.withTransaction,
+      // The version check can't see a writer racing it on a driver that opens
+      // deferred transactions, but the UNIQUE constraint can.
+      Effect.catchTag("SqlError", (error) => Effect.fail(isUniqueViolation(error) ? conflict : storeError("append")(error)))
+    )
+  }
+
+  const readBatch = (filter: EventStore.EventFilter, afterPosition: number, limit: number) => {
+    const oneStream = EventStore.isOneStream(filter)
+    const clauses = [
+      sql`position > ${afterPosition}`,
+      ...(oneStream ? [sql`version > ${filter.afterVersion ?? 0}`] : []),
+      ...(filter.aggregateNames === undefined ? [] : [sql.in("aggregate_name", filter.aggregateNames)]),
+      ...(filter.aggregateIds === undefined ? [] : [sql.in("aggregate_id", filter.aggregateIds)]),
+      ...(filter.eventTypes === undefined ? [] : [sql.in("type", filter.eventTypes)]),
+      ...(filter.startTime === undefined ? [] : [sql`timestamp >= ${DateTime.toEpochMillis(filter.startTime)}`]),
+      ...(filter.finishTime === undefined ? [] : [sql`timestamp < ${DateTime.toEpochMillis(filter.finishTime)}`])
+    ]
+    // Inside a stream versions follow positions, and only versions are indexed.
+    const order = oneStream ? sql`version` : sql`position`
+    return sql`SELECT ${columns} FROM ${events} WHERE ${sql.and(clauses)} ORDER BY ${order} LIMIT ${limit}`.pipe(
+      Effect.flatMap(decodeRows),
+      Effect.mapError(storeError("read"))
+    )
+  }
+
+  const head = sql<{ readonly position: number }>`SELECT COALESCE(MAX(position), 0) AS position FROM ${events}`.pipe(
+    Effect.map(([row]) => row?.position ?? 0),
+    Effect.mapError(storeError("head"))
+  )
+
+  return yield* EventStore.make({ append, readBatch, head })
+})
+
+export const layer = (options?: Options): Layer.Layer<EventStore.EventStore, EventStore.EventStoreError, SqlClient.SqlClient> =>
+  Layer.effect(EventStore.EventStore, make(options))
+
+/** Keeps checkpoints in the same database, for view models that are durable too. */
+export const layerCheckpoints = (options?: Options): Layer.Layer<Checkpoints, EventStore.EventStoreError, SqlClient.SqlClient> =>
+  Layer.effect(
+    Checkpoints,
+    Effect.gen(function*() {
+      const sql = yield* SqlClient.SqlClient
+      const table = sql(options?.checkpointsTable ?? "cqrs_checkpoints")
+
+      yield* sql`
+        CREATE TABLE IF NOT EXISTS ${table} (
+          view_model TEXT PRIMARY KEY,
+          position INTEGER NOT NULL
+        )
+      `.pipe(Effect.mapError(storeError("initialize")))
+
+      return Checkpoints.of({
+        get: (viewModel) =>
+          sql<{ readonly position: number }>`SELECT position FROM ${table} WHERE view_model = ${viewModel}`.pipe(
+            Effect.map(([row]) => row?.position ?? 0),
+            Effect.mapError(storeError("checkpoint"))
+          ),
+        set: (viewModel, position) =>
+          sql`
+            INSERT INTO ${table} (view_model, position) VALUES (${viewModel}, ${position})
+            ON CONFLICT (view_model) DO UPDATE SET position = excluded.position
+          `.pipe(
+            Effect.asVoid,
+            Effect.mapError(storeError("checkpoint"))
+          )
+      })
+    })
+  )