sailfork / t3code-github / .repos/ alchemy-effect/ examples/ cloudflare-domain/ packages/ domain/ src/ Transfer/ TransferStatus.view.ts

import * as Domain from "@alchemy.run/domain";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import { Account } from "../Account/Account.aggregate.ts";
import { AccountId } from "../Account/Account.id.ts";
import { NotOwner } from "../Account/NotOwner.rejection.ts";
import { Actor } from "../Actor.ts";
import { CurrentActor } from "../CurrentActor.context.ts";
import { Cents } from "../Money.ts";
import { Session } from "../Session.middleware.ts";
import { Transfer } from "./Transfer.aggregate.ts";

/**
 * The progress of one transfer, assembled from the Transfer and both
 * accounts. Each handler sets its own fact, so arrival order does not matter.
 * Its requester (or an agent) may read it; a recipient sees the transfer in
 * `AccountTransfers`.
 */
export class TransferStatus extends Domain.View("TransferStatus", {
  from: [Transfer, Account],
  key: Transfer,
  middleware: [Session],
  rejects: [NotOwner],
  keyOf: {
    TransferDebited: ({ event }) => Transfer.ref(event.transferId),
    TransferCredited: ({ event }) => Transfer.ref(event.transferId),
    TransferRefunded: ({ event }) => Transfer.ref(event.transferId),
  },
  state: Schema.Struct({
    from: Schema.NullOr(AccountId),
    to: Schema.NullOr(AccountId),
    amount: Schema.NullOr(Cents),
    requestedBy: Schema.NullOr(Actor),
    awaitingApproval: Schema.Boolean,
    debited: Schema.Boolean,
    credited: Schema.Boolean,
    refunded: Schema.Boolean,
    completedAt: Schema.NullOr(Schema.DateTimeUtc),
    failedReason: Schema.NullOr(Schema.String),
  }),
  initial: {
    from: null,
    to: null,
    amount: null,
    requestedBy: null,
    awaitingApproval: false,
    debited: false,
    credited: false,
    refunded: false,
    completedAt: null,
    failedReason: null,
  },
  evolve: {
    TransferRequested: (v, e) => ({
      ...v,
      from: e.from,
      to: e.to,
      amount: e.amount,
      requestedBy: e.requestedBy,
      awaitingApproval: e.needsApproval,
    }),
    TransferApproved: (v) => ({ ...v, awaitingApproval: false }),
    TransferDebited: (v) => ({ ...v, debited: true }),
    TransferCredited: (v) => ({ ...v, credited: true }),
    TransferRefunded: (v) => ({ ...v, refunded: true }),
    TransferCompleted: (v, _, { at }) => ({ ...v, completedAt: at }),
    TransferFailed: (v, e) => ({ ...v, awaitingApproval: false, failedReason: e.reason }),
  },
  validate: Effect.fn(function* (_request, status) {
    const actor = yield* CurrentActor;
    // Nothing to protect until the transfer is projected; agents may read any.
    if (actor._tag === "Agent" || status === null || status.requestedBy === null) return;
    const requester = status.requestedBy;
    if (
      actor._tag !== "Customer" ||
      requester._tag !== "Customer" ||
      requester.customerId !== actor.customerId
    ) {
      return yield* new NotOwner();
    }
  }),
  computed: {
    status: (v): "completed" | "failed" | "in-flight" | "awaiting-approval" | "pending" =>
      v.completedAt
        ? "completed"
        : v.failedReason
          ? "failed"
          : v.debited
            ? "in-flight"
            : v.awaitingApproval
              ? "awaiting-approval"
              : "pending",
  },
}) {}