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

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

/** How long a hold lasts before it expires, unless it is released first. */
export const HOLD_WINDOW = "15 seconds";

/** The command id a hold's expiry is scheduled under. */
export const EXPIRY = "expire";

export class HoldPlaced extends Domain.Event("HoldPlaced") {}
export class HoldReleased extends Domain.Event("HoldReleased") {}
export class HoldExpired extends Domain.Event("HoldExpired") {}

export class PlaceHold extends Domain.Command("PlaceHold", {
  target: Schema.String,
  events: [HoldPlaced],
}) {}
export class ReleaseHold extends Domain.Command("ReleaseHold", {
  target: Schema.String,
  events: [HoldReleased],
}) {}
/**
 * Records the expiry with no guard on state: only cancelling the schedule
 * keeps a released hold from expiring.
 */
export class ExpireHold extends Domain.Command("ExpireHold", {
  target: Schema.String,
  events: [HoldExpired],
}) {}

export class Hold extends Domain.Aggregate("Hold", {
  id: Schema.String,
  state: Schema.Struct({ status: Schema.Literals(["none", "held", "released", "expired"]) }),
  initial: { status: "none" },
  commands: [PlaceHold, ReleaseHold, ExpireHold],
  decide: {
    PlaceHold: () => [new HoldPlaced()],
    ReleaseHold: () => [new HoldReleased()],
    ExpireHold: () => [new HoldExpired()],
  },
  evolve: {
    HoldPlaced: () => ({ status: "held" as const }),
    HoldReleased: () => ({ status: "released" as const }),
    HoldExpired: () => ({ status: "expired" as const }),
  },
}) {}

/** Schedules a hold's expiry when it is placed, and cancels it when it is released. */
export class HoldDeadline extends Domain.Policy("HoldDeadline", {
  from: Hold,
  on: [HoldPlaced, HoldReleased],
}) {}

export const HoldDeadlineLive = HoldDeadline.toLayer(
  Effect.gen(function* () {
    const holds = yield* Hold;
    return Effect.fn(function* ({ source, event }) {
      if (event._tag === "HoldPlaced") {
        yield* holds
          .schedule(source, new ExpireHold(), { after: HOLD_WINDOW, commandId: EXPIRY })
          // a redelivery after the expiry ran: nothing to arm
          .pipe(Effect.catchTag("AlreadyExecuted", () => Effect.void));
      } else {
        yield* holds.unschedule(source, EXPIRY).pipe(
          // the hold expired first, and the release is recorded after it; a
          // redelivery, so the expiry is already cancelled; or the hold was
          // never placed, so there's no expiry
          Effect.catchTag(
            ["AlreadyExecuted", "AlreadyCancelled", "NotScheduled"],
            () => Effect.void,
          ),
        );
      }
    });
  }),
);

export class Holds extends Domain.Model("Holds", {
  aggregates: [Hold],
  policies: [HoldDeadline],
}) {}