effect-cqrs 0.0.0-stage → 0.2.0

package/src/Fixture.ts

@@ -0,0 +1,298 @@
+/**
+ * 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.
+ *
+ * The history can include events stored in older versions of their schema, made
+ * with `Aggregate.historical`, which then go through the same upcasting as events
+ * read from a real store.
+ */
+import { Arbitrary, Effect, Effectable, Schema } from "effect"
+import * 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"]
+
+/** An event in today's shape, or one stored in an older version of its schema. */
+export type GivenEvent<A extends Aggregate.Any> = Aggregate.Event<A> | Aggregate.Historical
+
+/** One generated step of {@link Fixture.checkInvariants}. */
+export type Step<A extends Aggregate.Any> = {
+  readonly [K in Aggregate.CommandName<A>]: { readonly command: K; readonly payload: Aggregate.Payload<A, K> }
+}[Aggregate.CommandName<A>]
+
+export interface InvariantOptions<A extends Aggregate.Any> {
+  /** Must hold for the given state and after every command that succeeds. */
+  readonly invariant: (state: Aggregate.State<A>) => boolean
+  /**
+   * How to generate each command's payload. By default it comes from the payload
+   * schema. `false` leaves a command out.
+   */
+  readonly commands?: {
+    readonly [K in Aggregate.CommandName<A>]?: Arbitrary.Arbitrary<Aggregate.Payload<A, K>> | false
+  } | undefined
+  /** The longest sequence of commands to try. Defaults to 20. */
+  readonly maxCommands?: number | undefined
+  /** Passed on to `Arbitrary.checkEffect`, for the number of runs or a seed. */
+  readonly check?: Arbitrary.CheckOptions | undefined
+}
+
+/**
+ * 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<GivenEvent<A>>): Fixture<A>
+  /** Like `given`, starting from an empty history by default and optionally switching aggregate id. */
+  givenEvents(events?: ReadonlyArray<GivenEvent<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>>
+  /**
+   * Runs random sequences of commands from the given history and checks that the
+   * invariant holds after each one that succeeds. Commands that fail are part of
+   * the game and are skipped. A violation dies with {@link ExpectationFailed},
+   * holding the shortest sequence found that breaks it.
+   */
+  checkInvariants(options: InvariantOptions<A>): Effect.Effect<void, 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<GivenEvent<A>>
+  }
+): Fixture<A> => {
+  const aggregateId = options?.aggregateId ?? "fixture-id"
+  const history = options?.events ?? []
+  const encodeEvent = AggregateService.makeEventEncoder(aggregate)
+  const encodeGiven = (event: GivenEvent<A>) =>
+    event instanceof Aggregate.Historical ? Effect.succeed(event) : encodeEvent(event)
+
+  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, encodeGiven)
+      })
+    }
+    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 checkInvariants = (options: InvariantOptions<A>) =>
+    Effect.gen(function*() {
+      const commands = Object.entries(aggregate.commands).flatMap(([name, command]) => {
+        const given = options.commands?.[name as Aggregate.CommandName<A>] as
+          | Arbitrary.Arbitrary<unknown>
+          | false
+          | undefined
+        if (given === false) return []
+        const payload = given ?? Arbitrary.schema(Schema.toType(command.payload))
+        return [[name, Arbitrary.map(payload, (payload: unknown) => ({ command: name, payload }))] as const]
+      })
+      if (commands.length === 0) {
+        return yield* Effect.die(new Error("checkInvariants needs at least one command to run"))
+      }
+      const byName = new Map(commands)
+      const steps = Arbitrary.array(
+        Arbitrary.flatMap(Arbitrary.schema(Schema.Literals(commands.map(([name]) => name))), (name) => byName.get(name)!),
+        { maxLength: options.maxCommands ?? 20 }
+      ) as Arbitrary.Arbitrary<ReadonlyArray<Step<A>>>
+
+      // Each run starts from a fresh store with the given history.
+      const holds = (sequence: ReadonlyArray<Step<A>>) =>
+        Effect.gen(function*() {
+          const service = yield* seeded
+          if (!options.invariant(yield* service.readModel(aggregateId))) return false
+          for (const step of sequence) {
+            const succeeded = yield* service.commands[step.command](aggregateId, step.payload).pipe(
+              Effect.as(true),
+              Effect.catch(() => Effect.succeed(false))
+            )
+            if (succeeded && !options.invariant(yield* service.readModel(aggregateId))) return false
+          }
+          return true
+        }).pipe(Effect.orDie)
+
+      const result = yield* Arbitrary.checkEffect(steps, holds, options.check)
+      if (result._tag !== "Passed") {
+        return yield* Effect.die(
+          new ExpectationFailed({
+            message: Arbitrary.formatCheckFailure(result) ?? "The invariant does not hold",
+            expected: "the invariant to hold after every command",
+            actual: result._tag === "Falsified" ? result.shrunkInput : result
+          })
+        )
+      }
+    })
+
+  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`)))
+      ),
+    checkInvariants
+  }
+
+  return fixture
+}

package/src/Metadata.ts

@@ -0,0 +1,52 @@
+/**
+ * Metadata: what a command carries beside its payload that the domain doesn't
+ * decide on, such as the version of the software that ran it, the user who sent
+ * it or the address it came from. It is a JSON object recorded on every event
+ * the command writes, and projections, view models and `history` can read it.
+ *
+ * Like `Causation`, it travels in the fiber's context rather than in payloads.
+ * A command records, key by key, from the lowest precedence:
+ *
+ * 1. the metadata where its aggregate service was built, such as the software
+ *    version provided once for the whole application with {@link layer};
+ * 2. the metadata where it runs, added with {@link withMetadata};
+ * 3. the `metadata` of a `dispatch` envelope.
+ *
+ * A view model or saga reacting to an event doesn't inherit that event's
+ * metadata: its commands record their own. The `causationId` leads back to the
+ * event, and from there to its metadata.
+ */
+import { Context, Effect, Function, Layer, Schema } from "effect"
+
+/** A JSON object. */
+export type Metadata = Schema.JsonObject
+
+export const Metadata: Schema.Codec<Metadata> = Schema.JsonObject
+
+/** The metadata commands run in this fiber record, `{}` outside any. */
+export const CurrentMetadata = Context.Reference<Metadata>("effect-cqrs/Metadata", {
+  defaultValue: () => ({})
+})
+
+/** Runs an effect whose commands record this metadata on top of the current one. */
+export const withMetadata: {
+  (metadata: Metadata): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, metadata: Metadata): Effect.Effect<A, E, R>
+} = Function.dual(
+  2,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, metadata: Metadata) =>
+    CurrentMetadata.use((current) => Effect.provideService(effect, CurrentMetadata, { ...current, ...metadata }))
+)
+
+/**
+ * Provides metadata to everything built on top of this layer, for values that
+ * hold for the whole process such as the software version:
+ *
+ * ```ts
+ * AppLayer.pipe(Layer.provide(Metadata.layer({ appVersion: "1.4.0" })))
+ * ```
+ *
+ * Aggregate services remember it, so it is recorded even by commands run where
+ * the layer isn't visible.
+ */
+export const layer = (metadata: Metadata): Layer.Layer<never> => Layer.succeed(CurrentMetadata, metadata)

package/src/PostgresEventStore.ts

@@ -0,0 +1,199 @@
+/**
+ * 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 11.
+const rowsPerInsert = 2_900
+
+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,
+        schema_version INTEGER NOT NULL DEFAULT 1,
+        payload JSONB NOT NULL,
+        "timestamp" BIGINT NOT NULL,
+        correlation_id TEXT,
+        causation_id TEXT,
+        metadata JSONB NOT NULL DEFAULT '{}',
+        UNIQUE (aggregate_name, aggregate_id, version)
+      )
+    `
+    // Tables created before these columns existed get them here.
+    yield* sql`ALTER TABLE ${events} ADD COLUMN IF NOT EXISTS schema_version INTEGER NOT NULL DEFAULT 1`
+    yield* sql`ALTER TABLE ${events} ADD COLUMN IF NOT EXISTS correlation_id TEXT`
+    yield* sql`ALTER TABLE ${events} ADD COLUMN IF NOT EXISTS causation_id TEXT`
+    yield* sql`ALTER TABLE ${events} ADD COLUMN IF NOT EXISTS metadata JSONB NOT NULL DEFAULT '{}'`
+    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,
+    schema_version AS "schemaVersion",
+    payload,
+    "timestamp"::float8 AS "timestamp",
+    correlation_id AS "correlationId",
+    causation_id AS "causationId",
+    metadata
+  `)
+
+  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.toStored(input, event, index, first + index, 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,
+        schema_version: event.schemaVersion,
+        payload: JSON.stringify(event.payload),
+        timestamp,
+        correlation_id: event.correlationId,
+        causation_id: event.causationId,
+        metadata: JSON.stringify(event.metadata)
+      }))
+      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"))
+          )
+      })
+    })
+  )