sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Cloudflare/ Domain/ fixtures/ tours.ts

import * as Domain from "@alchemy.run/domain";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

/** Tours belong to an org; there is no Org aggregate, the org views are keyed by its id. */
export const OrgId = Schema.String.pipe(Schema.brand("OrgId"));

export class TourBooked extends Domain.Event("TourBooked", {
  orgId: OrgId,
  unit: Schema.String,
}) {}
export class TourCancelled extends Domain.Event("TourCancelled", { orgId: OrgId }) {}

export class BookTour extends Domain.Command("BookTour", {
  target: Schema.String,
  input: { orgId: OrgId, unit: Schema.String },
  events: [TourBooked],
}) {}
export class CancelTour extends Domain.Command("CancelTour", {
  target: Schema.String,
  input: { orgId: OrgId },
  events: [TourCancelled],
}) {}

export class Tour extends Domain.Aggregate("Tour", {
  id: Schema.String,
  state: Schema.Struct({}),
  initial: {},
  commands: [BookTour, CancelTour],
  decide: {
    BookTour: (_, { orgId, unit }) => [new TourBooked({ orgId, unit })],
    CancelTour: (_, { orgId }) => [new TourCancelled({ orgId })],
  },
  evolve: { TourBooked: (s) => s, TourCancelled: (s) => s },
}) {}

export class ScheduleChanged extends Domain.Event("ScheduleChanged", { open: Schema.Number }) {}

/** One instance per org: its open tours, by tour id. */
export class OrgSchedule extends Domain.View("OrgSchedule", {
  from: [Tour],
  key: OrgId,
  keyOf: { Tour: ({ event }) => event.orgId },
  state: Schema.Struct({ org: Schema.String, tours: Schema.Record(Schema.String, Schema.String) }),
  initial: { org: "", tours: {} },
  evolve: {
    TourBooked: (s, e, { key, source }) => ({
      org: key,
      tours: { ...s.tours, [source.id]: e.unit },
    }),
    TourCancelled: (s, _, { source }) => {
      const { [source.id]: _cancelled, ...tours } = s.tours;
      return { ...s, tours };
    },
  },
  events: [ScheduleChanged],
  emit: {
    Tour: (_, { after }) => new ScheduleChanged({ open: Object.keys(after?.tours ?? {}).length }),
  },
}) {}

/** Keyed by the same schema as OrgSchedule, so it follows it without `keyOf`. */
export class OrgBusy extends Domain.View("OrgBusy", {
  from: [OrgSchedule],
  key: OrgId,
  state: Schema.Struct({ org: Schema.String, busy: Schema.Boolean }),
  initial: { org: "", busy: false },
  evolve: {
    ScheduleChanged: (_, e, { source }) => ({ org: source, busy: e.open >= 2 }),
  },
}) {}

export class FeedItem extends Domain.Event("FeedItem", {
  tour: Schema.String,
  unit: Schema.String,
}) {}

/** One ordered log per org. */
export class OrgFeed extends Domain.Stream("OrgFeed", { key: OrgId, entries: [FeedItem] }) {}

/** Writes each org's feed; `key` is the org id. */
export class OrgFeedWriter extends Domain.Projection("OrgFeedWriter", {
  from: [Tour],
  key: OrgId,
  keyOf: { Tour: ({ event }) => event.orgId },
  on: [TourBooked],
  writes: [OrgFeed],
}) {}
export const OrgFeedWriterLive = OrgFeedWriter.toLayer(
  Effect.gen(function* () {
    const feed = yield* OrgFeed;
    return Effect.fn(function* (batch) {
      for (const input of batch) {
        yield* feed.append(input, new FeedItem({ tour: input.source.id, unit: input.event.unit }));
      }
    });
  }),
);

export class Noted extends Domain.Event("Noted", { tour: Schema.String }) {}
export class Note extends Domain.Command("Note", {
  target: Schema.String,
  input: { tour: Schema.String },
  events: [Noted],
}) {}
/** An org's bookings, as notes. Its ids are org ids. */
export class Board extends Domain.Aggregate("Board", {
  id: Schema.String,
  state: Schema.Struct({ notes: Schema.Array(Schema.String) }),
  initial: { notes: [] },
  commands: [Note],
  decide: { Note: (_, { tour }) => [new Noted({ tour })] },
  evolve: { Noted: (s, e) => ({ notes: [...s.notes, e.tour] }) },
}) {}

/** A policy keyed by the org id: bookings of one org run in order. */
export class NoteBookings extends Domain.Policy("NoteBookings", {
  from: Tour,
  key: OrgId,
  keyOf: { TourBooked: ({ event }) => event.orgId },
  on: [TourBooked],
}) {}
export const NoteBookingsLive = NoteBookings.toLayer(
  Effect.gen(function* () {
    const boards = yield* Board;
    return Effect.fn(function* ({ key, source }) {
      yield* boards.send(key, new Note({ tour: source.id }));
    });
  }),
);

export class Tours extends Domain.Model("Tours", {
  aggregates: [Tour, Board],
  views: [OrgSchedule, OrgBusy],
  projections: [OrgFeedWriter],
  streams: [OrgFeed],
  policies: [NoteBookings],
}) {}