sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Domain/ CatchUp.test.ts

import * as Domain from "@alchemy.run/domain";
import * as InMemory from "@alchemy.run/domain/InMemory";
import { describe, expect, it } from "@alchemy.run/test";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";

// ---------------------------------------------------------------- two aggregates

class Deposited extends Domain.Event("Deposited", { amount: Schema.Number }) {}
class Deposit extends Domain.Command("Deposit", {
  target: Schema.String,
  input: { amount: Schema.Number },
  events: [Deposited],
}) {}
class Account extends Domain.Aggregate("Account", {
  id: Schema.String,
  state: Schema.Struct({ balance: Schema.Number }),
  initial: { balance: 0 },
  commands: [Deposit],
  decide: { Deposit: (_, cmd) => [new Deposited({ amount: cmd.amount })] },
  evolve: { Deposited: (s, e) => ({ balance: s.balance + e.amount }) },
}) {}

class Logged extends Domain.Event("Logged", { note: Schema.String }) {}
class Log extends Domain.Command("Log", {
  target: Schema.String,
  input: { note: Schema.String },
  events: [Logged],
}) {}
class Journal extends Domain.Aggregate("Journal", {
  id: Schema.String,
  state: Schema.Struct({}),
  initial: {},
  commands: [Log],
  decide: { Log: (_, cmd) => [new Logged({ note: cmd.note })] },
  evolve: { Logged: (s) => s },
}) {}

// ---------------------------------------------------------------- consumers added later

/** Every deposit to an account, in the order the view applied them. */
class Deposits extends Domain.View("Deposits", {
  from: [Account],
  key: Account,
  state: Schema.Struct({ amounts: Schema.Array(Schema.Number) }),
  initial: { amounts: [] },
  evolve: { Deposited: (s, e) => ({ amounts: [...s.amounts, e.amount] }) },
}) {}

/** Counts what reaches it: a policy must never act on replayed history. */
class Reactions extends Context.Service<Reactions, Ref.Ref<number>>()("Test/Reactions") {}
class OnDeposit extends Domain.Policy("OnDeposit", { from: [Deposits], on: [Deposited] }) {}
const OnDepositLive = OnDeposit.toLayer(
  Effect.gen(function* () {
    const reactions = yield* Reactions;
    return Effect.fn(function* () {
      yield* Ref.update(reactions, (n) => n + 1);
    });
  }),
);

/** A store outside the model: what one projection key received, in order. */
class Feed extends Context.Service<Feed, Ref.Ref<ReadonlyArray<string>>>()("Test/Feed") {}
class Timeline extends Domain.Projection("Timeline", {
  from: [Account, Journal],
  key: Schema.String,
  keyOf: { Deposited: () => "all", Logged: () => "all" },
  on: [Deposited, Logged],
}) {}
const timelineLayer = (options?: Domain.Projection.Options) =>
  Timeline.toLayer(
    Effect.gen(function* () {
      const feed = yield* Feed;
      return Effect.fn(function* (batch) {
        yield* Ref.update(feed, (all) => [
          ...all,
          ...batch.map(({ event }) =>
            event._tag === "Deposited" ? `deposit ${event.amount}` : `log ${event.note}`,
          ),
        ]);
      });
    }),
    options,
  );
const TimelineLive = timelineLayer();

/** The same view, redefined: it now records each deposit doubled. */
class DoubledDeposits extends Domain.View("Deposits", {
  from: [Account],
  key: Account,
  state: Schema.Struct({ amounts: Schema.Array(Schema.Number) }),
  initial: { amounts: [] },
  evolve: { Deposited: (s, e) => ({ amounts: [...s.amounts, e.amount * 2] }) },
}) {}

/** Every deposit, in the order the view applied them: one key. */
class Activity extends Domain.View("Activity", {
  from: [Account],
  key: Schema.String,
  keyOf: { Deposited: () => "all" },
  state: Schema.Struct({ entries: Schema.Array(Schema.String) }),
  initial: { entries: [] },
  evolve: { Deposited: (s, e) => ({ entries: [...s.entries, `deposit ${e.amount}`] }) },
}) {}

/** The same view, now reading the journal too. */
class WideActivity extends Domain.View("Activity", {
  from: [Account, Journal],
  key: Schema.String,
  keyOf: { Deposited: () => "all", Logged: () => "all" },
  state: Schema.Struct({ entries: Schema.Array(Schema.String) }),
  initial: { entries: [] },
  evolve: {
    Deposited: (s, e) => ({ entries: [...s.entries, `deposit ${e.amount}`] }),
    Logged: (s, e) => ({ entries: [...s.entries, `log ${e.note}`] }),
  },
}) {}

/** The views again, each at version 1: what bumping a version deploys. */
class DepositsV1 extends Domain.View("Deposits", { ...Deposits.definition, version: 1 }) {}
class DoubledDepositsV1 extends Domain.View("Deposits", {
  ...DoubledDeposits.definition,
  version: 1,
}) {}
class WideActivityV1 extends Domain.View("Activity", { ...WideActivity.definition, version: 1 }) {}

// ---------------------------------------------------------------- one model, three deploys

class Before extends Domain.Model("Bank", { aggregates: [Account, Journal] }) {}
class WithView extends Domain.Model("Bank", {
  aggregates: [Account, Journal],
  views: [Deposits],
  policies: [OnDeposit],
}) {}
class Redefined extends Domain.Model("Bank", {
  aggregates: [Account, Journal],
  views: [DoubledDeposits],
}) {}
class WithTimeline extends Domain.Model("Bank", {
  aggregates: [Account, Journal],
  projections: [Timeline],
}) {}

class WithActivity extends Domain.Model("Bank", {
  aggregates: [Account, Journal],
  views: [Activity],
}) {}
class WithWideActivity extends Domain.Model("Bank", {
  aggregates: [Account, Journal],
  views: [WideActivity],
}) {}
class WithWideActivityV1 extends Domain.Model("Bank", {
  aggregates: [Account, Journal],
  views: [WideActivityV1],
}) {}
class WithViewV1 extends Domain.Model("Bank", {
  aggregates: [Account, Journal],
  views: [DepositsV1],
}) {}
class RedefinedV1 extends Domain.Model("Bank", {
  aggregates: [Account, Journal],
  views: [DoubledDepositsV1],
}) {}

const HOUR = 60 * 60 * 1000;

/**
 * An in-memory platform that outlives the models built on it, as storage
 * outlives a deploy. `deploy` builds a model on it and runs `effect` against
 * that build; the platform delivers only when drained.
 */
const platform = () => {
  const clock = { now: 0 };
  const hosted = InMemory.make({ manual: true, now: () => clock.now });
  const services = Layer.mergeAll(
    Layer.effect(Reactions, Ref.make(0)),
    Layer.effect(Feed, Ref.make<ReadonlyArray<string>>([])),
  );
  // Deliver everything queued, and wait for the projection runs it forks.
  const settle: Effect.Effect<void> = Effect.gen(function* () {
    while (true) {
      yield* hosted.control.drain;
      if (yield* hosted.control.idle) return;
      yield* Effect.sleep("1 millis");
    }
  });
  return {
    clock,
    hosted,
    settle,
    services,
    deploy: <A, E, R, P, PE, PR>(
      model: { readonly layer: (policies: any, options?: any) => Layer.Layer<any, any, any> },
      policies: Layer.Layer<P, PE, PR>,
      effect: Effect.Effect<A, E, R>,
      options?: Domain.Model.LayerOptions,
    ) =>
      effect.pipe(
        Effect.tap(() => settle),
        Effect.provide(model.layer(policies, options).pipe(Layer.provide(hosted.layer))),
      ),
  };
};

const deposit = (id: string, amount: number) =>
  Effect.gen(function* () {
    const accounts = yield* Account;
    yield* accounts.send(Account.ref(id), new Deposit({ amount }));
  });

const amounts = (id: string) =>
  Effect.gen(function* () {
    const view = yield* Deposits;
    return Option.getOrUndefined(yield* view.query(Account.ref(id)))?.amounts;
  });

describe("Domain catch-up", () => {
  it.live(
    "a view that reads more sources without a version bump fails the deploy; with one, it is rebuilt from all of them",
    () =>
      Effect.gen(function* () {
        const bank = platform();
        yield* bank.deploy(
          Before,
          Layer.empty,
          Effect.gen(function* () {
            yield* deposit("a-1", 10);
            const journals = yield* Journal;
            yield* journals.send(Journal.ref("j-1"), new Log({ note: "opened" }));
          }),
        );
        yield* bank.deploy(WithActivity, Layer.empty, bank.settle);
        // Its backfill read Account only: waiting on it would miss the journal's history.
        const refused = yield* bank.deploy(WithWideActivity, Layer.empty, Effect.void).pipe(
          Effect.as(""),
          Effect.catchCause((cause) => Effect.succeed(String(cause))),
        );
        expect(refused).toContain("BackfillPlanChanged");
        expect(refused).toContain("Bump its version");
        const entries = yield* bank.deploy(
          WithWideActivityV1,
          Layer.empty,
          Effect.gen(function* () {
            yield* bank.settle;
            const view = yield* WideActivityV1;
            return Option.getOrUndefined(yield* view.query("all"))?.entries;
          }),
        );
        expect([...(entries ?? [])].sort()).toEqual(["deposit 10", "log opened"]);
      }).pipe(Effect.provide(platform().services)),
  );

  it.live("a view added later folds the events recorded before it", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(
        Before,
        Layer.empty,
        Effect.all([deposit("a-1", 10), deposit("a-1", 20), deposit("a-2", 5)]),
      );
      const [a1, a2] = yield* bank.deploy(
        WithView,
        OnDepositLive,
        Effect.gen(function* () {
          yield* bank.settle;
          return [yield* amounts("a-1"), yield* amounts("a-2")] as const;
        }),
      );
      expect(a1).toEqual([10, 20]);
      expect(a2).toEqual([5]);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("events committed while a view catches up arrive after its history", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(Before, Layer.empty, Effect.all([deposit("a-1", 1), deposit("a-1", 2)]));
      const result = yield* bank.deploy(
        WithView,
        OnDepositLive,
        // The sweep is queued but not run yet: this commit lands first.
        deposit("a-1", 3).pipe(
          Effect.andThen(bank.settle),
          Effect.andThen(deposit("a-1", 4)),
          Effect.andThen(bank.settle),
          Effect.andThen(amounts("a-1")),
        ),
      );
      expect(result).toEqual([1, 2, 3, 4]);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("policies never act on replayed history", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(Before, Layer.empty, Effect.all([deposit("a-1", 1), deposit("a-2", 2)]));
      const reactions = yield* bank.deploy(
        WithView,
        OnDepositLive,
        Effect.gen(function* () {
          yield* bank.settle;
          const replayed = yield* Ref.get(yield* Reactions);
          yield* deposit("a-1", 3);
          yield* bank.settle;
          return { replayed, live: (yield* Ref.get(yield* Reactions)) - replayed };
        }),
      );
      expect(reactions).toEqual({ replayed: 0, live: 1 });
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("a view removed, then added back with a new version, is rebuilt with everything", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(WithView, OnDepositLive, deposit("a-1", 1));
      yield* bank.deploy(Before, Layer.empty, deposit("a-1", 2));
      const result = yield* bank.deploy(
        WithViewV1,
        Layer.empty,
        bank.settle.pipe(
          Effect.andThen(
            Effect.gen(function* () {
              const view = yield* DepositsV1;
              return Option.getOrUndefined(yield* view.query(Account.ref("a-1")))?.amounts;
            }),
          ),
        ),
      );
      expect(result).toEqual([1, 2]);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("a redeploy does not replay history to a view that has it", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(WithView, OnDepositLive, deposit("a-1", 1));
      const result = yield* bank.deploy(
        WithView,
        OnDepositLive,
        deposit("a-1", 2).pipe(Effect.andThen(bank.settle), Effect.andThen(amounts("a-1"))),
      );
      expect(result).toEqual([1, 2]);
      expect(yield* Ref.get(yield* Reactions)).toBe(2);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("a projection added later receives many instances' history in time order", () =>
    Effect.gen(function* () {
      const bank = platform();
      const at = <R>(hours: number, effect: Effect.Effect<void, never, R>) =>
        Effect.sync(() => {
          bank.clock.now = hours * HOUR;
        }).pipe(Effect.andThen(effect));
      const log = (id: string, note: string) =>
        Effect.gen(function* () {
          yield* (yield* Journal).send(Journal.ref(id), new Log({ note }));
        });
      yield* bank.deploy(
        Before,
        Layer.empty,
        Effect.all([
          at(0, deposit("a-1", 1)),
          at(1, log("j-1", "one")),
          at(3, deposit("a-1", 3)),
          at(4, log("j-1", "four")),
          at(6, deposit("a-2", 6)),
        ]),
      );
      const feed = yield* bank.deploy(
        WithTimeline,
        TimelineLive,
        bank.settle.pipe(Effect.andThen(Effect.flatMap(Feed, Ref.get))),
      );
      // Each instance alone would replay all of its history at once:
      // deposit 1, deposit 3, log one, log four.
      expect(feed).toEqual(["deposit 1", "log one", "deposit 3", "log four", "deposit 6"]);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("a new view's history says when it is complete", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(Before, Layer.empty, deposit("a-1", 1));
      const [before, after] = yield* bank.deploy(
        WithView,
        OnDepositLive,
        Effect.gen(function* () {
          const view = yield* Deposits;
          const before = yield* view.history;
          yield* bank.settle;
          return [before, yield* view.history] as const;
        }),
      );
      expect(before.complete).toBe(false);
      expect(after.complete).toBe(true);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("instances created and written while a view catches up are folded once", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(Before, Layer.empty, Effect.all([deposit("a-1", 1), deposit("a-2", 2)]));
      const result = yield* bank.deploy(
        WithView,
        OnDepositLive,
        Effect.gen(function* () {
          // Before the sweep runs: a new instance, and a write to an inactive one.
          yield* deposit("a-9", 9);
          yield* deposit("a-2", 3);
          yield* bank.settle;
          return [yield* amounts("a-1"), yield* amounts("a-2"), yield* amounts("a-9")];
        }),
      );
      expect(result).toEqual([[1], [2, 3], [9]]);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("a catch-up started again after an interrupted deploy delivers each event once", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(Before, Layer.empty, Effect.all([deposit("a-1", 1), deposit("a-1", 2)]));
      // The first deploy with the view is replaced before its catch-up runs; both sweeps run.
      const first = WithView.layer(OnDepositLive).pipe(Layer.provide(bank.hosted.layer));
      yield* Effect.provide(Effect.void, first);
      const result = yield* bank.deploy(
        WithView,
        OnDepositLive,
        bank.settle.pipe(Effect.andThen(amounts("a-1"))),
      );
      expect(result).toEqual([1, 2]);
      expect(yield* Ref.get(yield* Reactions)).toBe(0);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("bumping a view's version rebuilds it from the history", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(
        WithView,
        OnDepositLive,
        Effect.all([deposit("a-1", 1), deposit("a-1", 2)]),
      );
      const doubled = (id: string) =>
        Effect.gen(function* () {
          const view = yield* DoubledDeposits;
          return Option.getOrUndefined(yield* view.query(Account.ref(id)))?.amounts;
        });
      // Redefined but not rebuilt: only new deposits are doubled, after the old state.
      const stale = yield* bank.deploy(
        Redefined,
        Layer.empty,
        deposit("a-1", 3).pipe(Effect.andThen(bank.settle), Effect.andThen(doubled("a-1"))),
      );
      expect(stale).toEqual([1, 2, 6]);
      // Keyed by its account: rebuilt in place. Nothing to wait for; each key
      // reads its account's events again before it answers.
      const rebuilt = yield* bank.deploy(
        RedefinedV1,
        Layer.empty,
        Effect.gen(function* () {
          const view = yield* DoubledDepositsV1;
          expect((yield* view.history).complete).toBe(true);
          const first = Option.getOrUndefined(yield* view.query(Account.ref("a-1")))?.amounts;
          expect(first).toEqual([2, 4, 6]);
          yield* deposit("a-1", 4);
          yield* bank.settle;
          return Option.getOrUndefined(yield* view.query(Account.ref("a-1")))?.amounts;
        }),
      );
      expect(rebuilt).toEqual([2, 4, 6, 8]);
      // A policy on the old view acted on the first two deposits only, never on the rebuild.
      expect(yield* Ref.get(yield* Reactions)).toBe(2);
    }).pipe(Effect.provide(platform().services)),
  );

  it.live("bumping a projection's version runs it again over the history", () =>
    Effect.gen(function* () {
      const bank = platform();
      yield* bank.deploy(
        WithTimeline,
        TimelineLive,
        Effect.all([deposit("a-1", 1), deposit("a-2", 2)]),
      );
      const feed = yield* bank.deploy(
        WithTimeline,
        timelineLayer({ version: 1 }),
        bank.settle.pipe(Effect.andThen(Effect.flatMap(Feed, Ref.get))),
      );
      expect(feed).toEqual(["deposit 1", "deposit 2", "deposit 1", "deposit 2"]);
    }).pipe(Effect.provide(platform().services)),
  );
});