A language an agent can finish.

event @stock.received {
  sku: String @max(64),
  quantity: Int,
}

event @stock.reserved {
  reservation_id: Uuid,
  sku: String @max(64),
  quantity: Int,
}

refusal NotEnoughStock(available: Int) "only {available} left for this sku"

command ReserveStock(reservation_id: Uuid, sku: String, wanted: Int) {
  // Every movement of this sku, which is what the reservation has to be
  // consistent with. Folding it is what conditions the append on it.
  fold on_hand: Int = 0
    on @stock.received(sku) { quantity } => on_hand + quantity
    on @stock.reserved(sku) { quantity } => on_hand - quantity

  if wanted <= 0 {
    return invalid("a reservation needs a positive quantity")
  }
  if wanted > on_hand {
    return reject NotEnoughStock { available: on_hand }
  }

  emit @stock.reserved { reservation_id, sku, quantity: wanted }
}

event @payment.recorded {
  payment_id: Uuid,
  customer_id: Int,
  email: String? @subject(customer_id) @max(200),
  amount: Money(2),
}

event @receipt.sent {
  payment_id: Uuid,
}

effect SendReceipt {
  on @payment.recorded { @key payment_id, email, amount } {
    if email.is_none() {
      log("payment {payment_id} has no address to send a receipt to")
      return
    }

    let response = http.post("https://mail.example/receipt", {
      "to": reveal(email),
      "amount": amount,
    })
    if response.status >= 400 {
      log("receipt rejected with status {response.status}")
      return
    }

    invoke RecordReceipt { payment_id }
  }
}

// Internal: an effect writes back to the log by invoking a command, never by
// appending, so the fact lands under this command's own boundary.
command RecordReceipt(payment_id: Uuid) {
  fold sent: Bool = false
    on @receipt.sent(payment_id) => true

  if sent {
    return
  }

  emit @receipt.sent { payment_id }
}

event @customer.registered {
  customer_id: Int,
  email: String? @subject(customer_id) @max(200),
}

event @customer.erasure.requested {
  customer_id: Int,
}

// Only an effect may erase, and the subject is on the trigger, so this one infers.
effect EraseCustomer {
  on @customer.erasure.requested { @key customer_id } {
    erase(customer_id)
    log("erased every value scoped to customer {customer_id}")
  }
}

event @ticket.opened {
  ticket_id: Uuid,
  assignee_id: Int,
  subject: String @max(200),
}

event @ticket.closed {
  ticket_id: Uuid,
}

projector OpenTickets {
  entity Ticket {
    ticket_id: Uuid @key,
    assignee_id: Int @index,
    subject: String @max(200),
  }

  on @ticket.opened { ticket_id, assignee_id, subject } {
    put Ticket { ticket_id, assignee_id, subject }
  }

  // `delete` rather than a status column: a closed ticket is not an open one.
  on @ticket.closed { ticket_id } {
    delete Ticket[ticket_id]
  }
}