# Generated from LogicScript — greet

class ValidationError(Exception):
    pass

def greet(name: str) -> str:
    """Returns a personalised greeting.

    Raises:
        ValidationError: If name is empty.
    """
    # VALIDATE: name not empty
    if not name or not name.strip():
        raise ValidationError("name must not be empty")

    # DO
    message = f"Hello, {name}."

    # RETURN
    return message


if __name__ == "__main__":
    print(greet("world"))  # Hello, world.

-- Generated from LogicScript — greet (PostgreSQL)

CREATE OR REPLACE FUNCTION greet(p_name TEXT)
RETURNS TEXT
LANGUAGE plpgsql AS $$
BEGIN
  -- VALIDATE: name not empty
  IF p_name IS NULL OR trim(p_name) = '' THEN
    RAISE EXCEPTION 'ValidationError: name must not be empty';
  END IF;

  -- DO + RETURN
  RETURN 'Hello, ' || p_name || '.';
END;
$$;

-- Usage:
-- SELECT greet('world');  -- Hello, world.

// Generated from LogicScript — greet

public class Greeter {

    public static class ValidationException extends RuntimeException {
        public ValidationException(String message) { super(message); }
    }

    /**
     * Returns a personalised greeting.
     * @throws ValidationException if name is null or blank
     */
    public static String greet(String name) {
        // VALIDATE: name not empty
        if (name == null || name.isBlank()) {
            throw new ValidationException("name must not be empty");
        }

        // DO + RETURN
        return "Hello, " + name + ".";
    }

    public static void main(String[] args) {
        System.out.println(greet("world")); // Hello, world.
    }
}

// Generated from LogicScript — greet

#[derive(Debug, thiserror::Error)]
pub enum ValidationError {
    #[error("name must not be empty")]
    EmptyName,
}

/// Returns a personalised greeting.
///
/// # Errors
/// Returns `ValidationError::EmptyName` if `name` is empty or whitespace.
pub fn greet(name: &str) -> Result {
    // VALIDATE: name not empty
    if name.trim().is_empty() {
        return Err(ValidationError::EmptyName);
    }

    // DO + RETURN
    Ok(format!("Hello, {}.", name))
}

fn main() {
    println!("{}", greet("world").unwrap()); // Hello, world.
}

// Generated from LogicScript — greet
#include <stdexcept>
#include <string>
#include <iostream>

class ValidationError : public std::runtime_error {
public:
    explicit ValidationError(const std::string& msg)
        : std::runtime_error(msg) {}
};

/// Returns a personalised greeting.
/// @throws ValidationError if name is empty or whitespace.
std::string greet(const std::string& name) {
    // VALIDATE: name not empty
    bool blank = name.find_first_not_of("

") == std::string::npos;
    if (name.empty() || blank) {
        throw ValidationError("name must not be empty");
    }

    // DO + RETURN
    return "Hello, " + name + ".";
}

int main() {
    std::cout << greet("world") << std::endl; // Hello, world.
}

# Generated from LogicScript — SHAPE User + FUNC createUser
import re, uuid, bcrypt, logging
from dataclasses import dataclass, field
from datetime   import datetime, timezone
from enum       import Enum

log = logging.getLogger(__name__)

class Role(Enum):
    ADMIN = "admin"; USER = "user"; GUEST = "guest"

@dataclass
class User:
    id:            str      = field(default_factory=lambda: str(uuid.uuid4()))
    email:         str      = ""
    name:          str      = ""
    password_hash: str      = ""
    role:          Role     = Role.USER
    created_at:    datetime = field(default_factory=lambda: datetime.now(timezone.utc))

class ValidationError(Exception):
    status_code = 422

EMAIL_RE = re.compile(r"^[^\s@]+@[^\s@]+\.[^\s@]+$")

def create_user(email: str, password: str, name: str, db, event_bus) -> User:
    """Creates a new user. Raises ValidationError if any check fails."""
    # VALIDATE
    if not EMAIL_RE.match(email):
        raise ValidationError("Invalid email format")
    if len(password) < 8:
        raise ValidationError("Password must be at least 8 characters")
    if len(name) < 2:
        raise ValidationError("Name must be at least 2 characters")
    if db.user_exists(email):
        raise ValidationError("Email already registered")

    # DO: hash + create
    hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
    user   = User(email=email, password_hash=hashed, name=name)
    db.save(user)

    # EMIT UserCreated
    event_bus.emit("UserCreated", user)
    return user

# ON UserCreated
def on_user_created(user: User):
    email_service.send_welcome(user.email, user.name)   # TRIGGER
    log.info(f"New signup: {user.email}")               # LOG

-- Generated from LogicScript — SHAPE User + FUNC createUser (PostgreSQL)
CREATE EXTENSION IF NOT EXISTS pgcrypto;
CREATE TYPE user_role AS ENUM ('admin', 'user', 'guest');

-- SHAPE User → CREATE TABLE
CREATE TABLE users (
  id            UUID         PRIMARY KEY DEFAULT gen_random_uuid(),
  email         TEXT         NOT NULL UNIQUE,
  name          VARCHAR(200) NOT NULL CHECK (length(name) >= 2),
  password_hash TEXT         NOT NULL,
  role          user_role    NOT NULL DEFAULT 'user',
  created_at    TIMESTAMPTZ  NOT NULL DEFAULT now()
);
CREATE INDEX idx_users_email ON users (email);

-- FUNC createUser → plpgsql function
CREATE OR REPLACE FUNCTION create_user(
  p_email TEXT, p_password TEXT, p_name TEXT
) RETURNS users LANGUAGE plpgsql AS $$
DECLARE v_hash TEXT; v_user users;
BEGIN
  -- VALIDATE
  IF p_email !~ '^[^\s@]+@[^\s@]+\.[^\s@]+$' THEN
    RAISE EXCEPTION 'ValidationError: invalid email format'; END IF;
  IF length(p_password) < 8 THEN
    RAISE EXCEPTION 'ValidationError: password too short'; END IF;
  IF length(p_name) < 2 THEN
    RAISE EXCEPTION 'ValidationError: name too short'; END IF;
  IF EXISTS(SELECT 1 FROM users WHERE email = p_email) THEN
    RAISE EXCEPTION 'ValidationError: email already registered'; END IF;

  -- DO: hash + insert
  v_hash := crypt(p_password, gen_salt('bf', 12));
  INSERT INTO users(email, name, password_hash)
    VALUES(p_email, p_name, v_hash) RETURNING * INTO v_user;

  -- EMIT UserCreated via pg_notify
  PERFORM pg_notify('user_created', row_to_json(v_user)::text);
  RETURN v_user;
END; $$;

// Generated from LogicScript — SHAPE User + FUNC createUser
import java.time.Instant;
import java.util.UUID;
import java.util.regex.Pattern;

public record User(UUID id, String email, String name,
                   String passwordHash, Role role, Instant createdAt) {
    public enum Role { ADMIN, USER, GUEST }
}

public class ValidationException extends RuntimeException {
    public final int statusCode = 422;
    public ValidationException(String msg) { super(msg); }
}

@Service
public class UserService {
    private static final Pattern EMAIL =
        Pattern.compile("^[^\s@]+@[^\s@]+\.[^\s@]+$");

    private final UserRepository     repo;
    private final PasswordEncoder    encoder;
    private final ApplicationEventPublisher publisher;
    private static final Logger log = LoggerFactory.getLogger(UserService.class);

    public User createUser(String email, String password, String name) {
        // VALIDATE
        if (!EMAIL.matcher(email).matches())
            throw new ValidationException("Invalid email format");
        if (password.length() < 8)
            throw new ValidationException("Password must be at least 8 characters");
        if (name.length() < 2)
            throw new ValidationException("Name must be at least 2 characters");
        if (repo.existsByEmail(email))
            throw new ValidationException("Email already registered");

        // DO: hash + create
        String hash = encoder.encode(password);
        User user = new User(UUID.randomUUID(), email, name, hash, User.Role.USER, Instant.now());
        user = repo.save(user);

        // EMIT UserCreated
        publisher.publishEvent(new UserCreatedEvent(this, user));
        return user;
    }
}

// ON UserCreated
@EventListener
public void onUserCreated(UserCreatedEvent event) {
    emailService.sendWelcome(event.user().email(), event.user().name()); // TRIGGER
    log.info("New signup: {}", event.user().email());                    // LOG
}

// Generated from LogicScript — SHAPE User + FUNC createUser
use uuid::Uuid;
use chrono::{DateTime, Utc};
use regex::Regex;
use std::sync::OnceLock;

#[derive(Debug, Clone, serde::Serialize)]
pub struct User {
    pub id:            Uuid,
    pub email:         String,
    pub name:          String,
    pub password_hash: String,
    pub role:          Role,
    pub created_at:    DateTime<Utc>,
}

#[derive(Debug, Clone, serde::Serialize, sqlx::Type)]
#[sqlx(type_name = "user_role", rename_all = "lowercase")]
pub enum Role { Admin, User, Guest }

#[derive(Debug, thiserror::Error)]
pub enum ValidationError {
    #[error("Invalid email format")]        InvalidEmail,
    #[error("Password must be >= 8 chars")] PasswordTooShort,
    #[error("Name must be >= 2 chars")]     NameTooShort,
    #[error("Email already registered")]    EmailTaken,
    #[error(transparent)] Db(#[from] sqlx::Error),
}

static EMAIL_RE: OnceLock<Regex> = OnceLock::new();

pub async fn create_user(
    pool: &sqlx::PgPool, bus: &impl EventBus,
    email: String, password: String, name: String,
) -> Result<User, ValidationError> {
    let re = EMAIL_RE.get_or_init(|| Regex::new(r"^[^\s@]+@[^\s@]+\.[^\s@]+$").unwrap());

    // VALIDATE
    if !re.is_match(&email)  { return Err(ValidationError::InvalidEmail); }
    if password.len() < 8   { return Err(ValidationError::PasswordTooShort); }
    if name.len() < 2        { return Err(ValidationError::NameTooShort); }
    let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM users WHERE email=$1)")
        .bind(&email).fetch_one(pool).await?;
    if exists { return Err(ValidationError::EmailTaken); }

    // DO: hash + insert
    let hash = bcrypt::hash(&password, bcrypt::DEFAULT_COST).unwrap();
    let user: User = sqlx::query_as(
        "INSERT INTO users(id,email,name,password_hash,role,created_at)
         VALUES($1,$2,$3,$4,'user',NOW()) RETURNING *")
        .bind(Uuid::new_v4()).bind(&email).bind(&name).bind(&hash)
        .fetch_one(pool).await?;

    // EMIT UserCreated
    bus.emit("UserCreated", &user).await;
    tracing::info!("New signup: {}", user.email); // LOG
    Ok(user)
}

// Generated from LogicScript — SHAPE User + FUNC createUser
#pragma once
#include <string>, <stdexcept>, <regex>, <chrono>
#include "uuid.hpp", "db.hpp", "event_bus.hpp", "bcrypt.hpp"

enum class Role { Admin, User, Guest };

struct User {
    std::string id, email, name, password_hash;
    Role        role{Role::User};
    std::chrono::system_clock::time_point created_at;
};

class ValidationError : public std::runtime_error {
public:
    int status_code = 422;
    explicit ValidationError(const std::string& msg) : std::runtime_error(msg) {}
};

class UserService {
public:
    UserService(Database& db, EventBus& bus)
        : db_(db), bus_(bus)
        , email_re_(R"(^[^\s@]+@[^\s@]+\.[^\s@]+$)", std::regex::ECMAScript) {}

    User createUser(std::string_view email, std::string_view password, std::string_view name) {
        // VALIDATE
        if (!std::regex_match(email.begin(), email.end(), email_re_))
            throw ValidationError("Invalid email format");
        if (password.size() < 8)
            throw ValidationError("Password must be at least 8 characters");
        if (name.size() < 2)
            throw ValidationError("Name must be at least 2 characters");
        if (db_.user_exists_by_email(email))
            throw ValidationError("Email already registered");

        // DO: hash + insert
        auto hash = bcrypt::hash(password, 12);
        User user{ uuid::v4(), std::string(email), std::string(name),
                   std::move(hash), Role::User, std::chrono::system_clock::now() };
        user = db_.insert_user(user);

        // EMIT UserCreated
        bus_.emit("UserCreated", user);
        return user;
    }
private:
    Database& db_; EventBus& bus_; std::regex email_re_;
};

# Generated from LogicScript — @transaction FUNC transferFunds
from datetime import datetime, timezone

class TransferError(Exception): pass

def transfer_funds(from_id: str, to_id: str, amount: float, db, event_bus) -> dict:
    """Moves funds atomically. Raises TransferError on any failure."""
    # VALIDATE
    if amount <= 0:
        raise TransferError("Amount must be positive")
    if from_id == to_id:
        raise TransferError("Cannot transfer to the same account")

    from_acct = db.query(Account).filter_by(id=from_id).one()
    if from_acct.balance < amount:
        raise TransferError("Insufficient funds")

    # @transaction → SQLAlchemy context manager; rolls back on any exception
    try:
        with db.begin():
            from_acct.balance -= amount
            to_acct = db.query(Account).filter_by(id=to_id).one()
            to_acct.balance   += amount
    except Exception as exc:
        raise TransferError(f"Transaction failed: {exc}") from exc

    # EMIT FundsTransferred
    event_bus.emit("FundsTransferred", {"from": from_id, "to": to_id, "amount": amount})
    return {"success": True, "timestamp": datetime.now(timezone.utc).isoformat()}

-- Generated from LogicScript — @transaction FUNC transferFunds (PostgreSQL)
-- Procedures run inside an implicit transaction; RAISE causes automatic rollback.

CREATE OR REPLACE PROCEDURE transfer_funds(
  p_from_id UUID, p_to_id UUID, p_amount NUMERIC(18,2)
) LANGUAGE plpgsql AS $$
DECLARE v_balance NUMERIC(18,2);
BEGIN
  -- VALIDATE
  IF p_amount <= 0 THEN
    RAISE EXCEPTION 'TransferError: amount must be positive'; END IF;
  IF p_from_id = p_to_id THEN
    RAISE EXCEPTION 'TransferError: cannot transfer to the same account'; END IF;

  -- Lock the source row to prevent race conditions
  SELECT balance INTO v_balance
    FROM accounts WHERE id = p_from_id FOR UPDATE;
  IF v_balance < p_amount THEN
    RAISE EXCEPTION 'TransferError: insufficient funds'; END IF;

  -- DO: atomic debit/credit — any error here triggers automatic ROLLBACK
  UPDATE accounts SET balance = balance - p_amount WHERE id = p_from_id;
  UPDATE accounts SET balance = balance + p_amount WHERE id = p_to_id;

  -- EMIT FundsTransferred via pg_notify
  PERFORM pg_notify('funds_transferred',
    json_build_object('from', p_from_id, 'to', p_to_id, 'amount', p_amount)::text);
END; $$;

-- Usage (caller controls outer transaction):
-- CALL transfer_funds('uuid-a', 'uuid-b', 100.00);

// Generated from LogicScript — @transaction FUNC transferFunds
import java.math.BigDecimal;
import java.time.Instant;
import java.util.Map;

public class TransferException extends RuntimeException {
    public TransferException(String msg) { super(msg); }
}

record TransferResult(boolean success, Instant timestamp) {}

@Service
public class TransferService {

    private final AccountRepository accountRepository;
    private final ApplicationEventPublisher publisher;

    // @transaction → Spring @Transactional rolls back on any RuntimeException
    @Transactional
    public TransferResult transferFunds(String fromId, String toId, BigDecimal amount) {
        // VALIDATE
        if (amount.compareTo(BigDecimal.ZERO) <= 0)
            throw new TransferException("Amount must be positive");
        if (fromId.equals(toId))
            throw new TransferException("Cannot transfer to the same account");

        Account from = accountRepository.findByIdWithLock(fromId) // SELECT FOR UPDATE
            .orElseThrow(() -> new TransferException("Account not found"));
        if (from.getBalance().compareTo(amount) < 0)
            throw new TransferException("Insufficient funds");

        // DO: debit + credit
        accountRepository.debit(fromId, amount);
        accountRepository.credit(toId,  amount);

        // EMIT FundsTransferred
        publisher.publishEvent(new FundsTransferredEvent(this, fromId, toId, amount));

        return new TransferResult(true, Instant.now());
    }
}

// Generated from LogicScript — @transaction FUNC transferFunds
use rust_decimal::Decimal;
use uuid::Uuid;
use serde_json::json;

#[derive(Debug, thiserror::Error)]
pub enum TransferError {
    #[error("Amount must be positive")]               InvalidAmount,
    #[error("Cannot transfer to the same account")]   SameAccount,
    #[error("Insufficient funds")]                    InsufficientFunds,
    #[error(transparent)]                             Db(#[from] sqlx::Error),
}

pub async fn transfer_funds(
    pool: &sqlx::PgPool, bus: &impl EventBus,
    from_id: Uuid, to_id: Uuid, amount: Decimal,
) -> Result<(), TransferError> {
    // VALIDATE
    if amount <= Decimal::ZERO { return Err(TransferError::InvalidAmount); }
    if from_id == to_id         { return Err(TransferError::SameAccount); }

    // @transaction — explicit sqlx transaction; rollback on any ? error
    let mut tx = pool.begin().await?;

    let balance: Decimal = sqlx::query_scalar(
        "SELECT balance FROM accounts WHERE id = $1 FOR UPDATE")
        .bind(from_id).fetch_one(&mut *tx).await?;

    if balance < amount {
        tx.rollback().await?;
        return Err(TransferError::InsufficientFunds);
    }

    // DO: debit + credit
    sqlx::query("UPDATE accounts SET balance = balance - $1 WHERE id = $2")
        .bind(amount).bind(from_id).execute(&mut *tx).await?;
    sqlx::query("UPDATE accounts SET balance = balance + $1 WHERE id = $2")
        .bind(amount).bind(to_id).execute(&mut *tx).await?;

    tx.commit().await?; // rolls back automatically if any step above failed

    // EMIT FundsTransferred
    bus.emit("FundsTransferred", &json!({"from": from_id, "to": to_id, "amount": amount})).await;
    Ok(())
}

// Generated from LogicScript — @transaction FUNC transferFunds
#include <stdexcept>, <string>, <chrono>
#include "db.hpp", "event_bus.hpp"

class TransferError : public std::runtime_error {
public:
    explicit TransferError(const std::string& msg) : std::runtime_error(msg) {}
};

struct TransferResult { bool success; std::chrono::system_clock::time_point timestamp; };

class PaymentService {
public:
    TransferResult transferFunds(
        const std::string& from_id, const std::string& to_id, double amount)
    {
        // VALIDATE
        if (amount <= 0.0)    throw TransferError("Amount must be positive");
        if (from_id == to_id) throw TransferError("Cannot transfer to the same account");

        auto from = db_.get_account_for_update(from_id);  // locks the row
        if (from.balance < amount) throw TransferError("Insufficient funds");

        // @transaction — RAII: rolls back in destructor if not committed
        auto txn = db_.begin_transaction();
        try {
            db_.debit(from_id, amount, txn);
            db_.credit(to_id,  amount, txn);
            txn.commit();
        } catch (...) {
            txn.rollback();   // ROLLBACK
            throw;
        }

        // EMIT FundsTransferred
        bus_.emit("FundsTransferred", {from_id, to_id, amount});
        return { true, std::chrono::system_clock::now() };
    }
private:
    Database& db_;
    EventBus&  bus_;
};

# Generated from LogicScript — STATE Order
import logging
from enum import Enum

log = logging.getLogger(__name__)

class OrderStatus(Enum):
    DRAFT     = "draft"
    PENDING   = "pending"
    PAID      = "paid"
    SHIPPED   = "shipped"
    DELIVERED = "delivered"
    CANCELLED = "cancelled"

TRANSITIONS = {
    "submitOrder":       ([OrderStatus.DRAFT],                                   OrderStatus.PENDING),
    "paymentReceived":   ([OrderStatus.PENDING],                                 OrderStatus.PAID),
    "fulfillOrder":      ([OrderStatus.PAID],                                    OrderStatus.SHIPPED),
    "deliveryConfirmed": ([OrderStatus.SHIPPED],                                 OrderStatus.DELIVERED),
    "cancelOrder":       ([OrderStatus.DRAFT, OrderStatus.PENDING,
                           OrderStatus.PAID,  OrderStatus.SHIPPED],              OrderStatus.CANCELLED),
}

def transition_order(order, event: str, db, event_bus, notification_service):
    if event not in TRANSITIONS:
        raise ValueError(f"Unknown event: {event}")

    from_states, to_status = TRANSITIONS[event]
    if order.status not in from_states:
        raise ValueError(f"Invalid transition from {order.status.value} via {event}")

    order.status = to_status
    db.save(order)

    # ON ENTER hooks
    if to_status == OrderStatus.SHIPPED:
        event_bus.emit("OrderShipped", order)                           # EMIT
        notification_service.notify_user(order.user_id, order.tracking_info)  # NOTIFY

    if to_status == OrderStatus.CANCELLED:
        refund_if_paid(order)                                           # TRIGGER
        log.info(f"Order {order.id} cancelled")                        # LOG

    return order

-- Generated from LogicScript — STATE Order (PostgreSQL)
CREATE TYPE order_status AS ENUM
  ('draft','pending','paid','shipped','delivered','cancelled');

CREATE OR REPLACE PROCEDURE transition_order(p_order_id UUID, p_event TEXT)
LANGUAGE plpgsql AS $$
DECLARE
  v_current order_status;
  v_next    order_status;
BEGIN
  SELECT status INTO v_current FROM orders WHERE id = p_order_id FOR UPDATE;

  -- TRANSITION table
  v_next := CASE
    WHEN p_event = 'submitOrder'       AND v_current = 'draft'    THEN 'pending'
    WHEN p_event = 'paymentReceived'   AND v_current = 'pending'  THEN 'paid'
    WHEN p_event = 'fulfillOrder'      AND v_current = 'paid'     THEN 'shipped'
    WHEN p_event = 'deliveryConfirmed' AND v_current = 'shipped'  THEN 'delivered'
    WHEN p_event = 'cancelOrder'
         AND v_current IN ('draft','pending','paid','shipped')     THEN 'cancelled'
    ELSE NULL
  END;

  IF v_next IS NULL THEN
    RAISE EXCEPTION 'Invalid transition: % via %', v_current, p_event;
  END IF;

  UPDATE orders SET status = v_next WHERE id = p_order_id;

  -- ON ENTER hooks via pg_notify
  IF v_next = 'shipped' THEN
    PERFORM pg_notify('order_shipped',   p_order_id::text);
  END IF;
  IF v_next = 'cancelled' THEN
    PERFORM pg_notify('order_cancelled', p_order_id::text);
    PERFORM refund_if_paid(p_order_id);
  END IF;
END; $$;

// Generated from LogicScript — STATE Order
import java.util.*;

public enum OrderStatus { DRAFT, PENDING, PAID, SHIPPED, DELIVERED, CANCELLED }

@Service
public class OrderStateMachine {
    private record Transition(Set<OrderStatus> from, OrderStatus to) {}
    private static final Logger log = LoggerFactory.getLogger(OrderStateMachine.class);

    private static final Map<String, Transition> TRANSITIONS = Map.of(
        "submitOrder",       new Transition(Set.of(DRAFT),                          PENDING),
        "paymentReceived",   new Transition(Set.of(PENDING),                        PAID),
        "fulfillOrder",      new Transition(Set.of(PAID),                           SHIPPED),
        "deliveryConfirmed", new Transition(Set.of(SHIPPED),                        DELIVERED),
        "cancelOrder",       new Transition(Set.of(DRAFT,PENDING,PAID,SHIPPED),     CANCELLED)
    );

    public Order transition(Order order, String event) {
        Transition t = TRANSITIONS.get(event);
        if (t == null)                        throw new IllegalArgumentException("Unknown event: " + event);
        if (!t.from().contains(order.getStatus()))
            throw new IllegalStateException("Invalid transition from " + order.getStatus());

        order.setStatus(t.to());
        order = orderRepository.save(order);

        // ON ENTER hooks
        if (t.to() == SHIPPED) {
            publisher.publishEvent(new OrderShippedEvent(this, order));     // EMIT
            notifService.notifyUser(order.getUserId(), order.getTracking()); // NOTIFY
        }
        if (t.to() == CANCELLED) {
            refundService.refundIfPaid(order);                              // TRIGGER
            log.info("Order {} cancelled", order.getId());                  // LOG
        }
        return order;
    }
}

// Generated from LogicScript — STATE Order
#[derive(Debug, Clone, PartialEq, sqlx::Type, serde::Serialize)]
#[sqlx(type_name = "order_status", rename_all = "lowercase")]
pub enum OrderStatus { Draft, Pending, Paid, Shipped, Delivered, Cancelled }

#[derive(Debug, thiserror::Error)]
pub enum TransitionError {
    #[error("Unknown event: {0}")]                  UnknownEvent(String),
    #[error("Invalid transition from {0:?} via {1}")] Invalid(OrderStatus, String),
    #[error(transparent)]                           Db(#[from] sqlx::Error),
}

pub async fn transition_order(
    pool: &sqlx::PgPool, bus: &impl EventBus,
    order: &mut Order, event: &str,
) -> Result<(), TransitionError> {
    use OrderStatus::*;
    let next = match (event, &order.status) {
        ("submitOrder",       Draft)   => Pending,
        ("paymentReceived",   Pending) => Paid,
        ("fulfillOrder",      Paid)    => Shipped,
        ("deliveryConfirmed", Shipped) => Delivered,
        ("cancelOrder", Draft | Pending | Paid | Shipped) => Cancelled,
        ("cancelOrder", _) => return Err(TransitionError::Invalid(order.status.clone(), event.into())),
        _                  => return Err(TransitionError::UnknownEvent(event.into())),
    };

    order.status = next.clone();
    sqlx::query("UPDATE orders SET status=$1 WHERE id=$2")
        .bind(&next).bind(order.id).execute(pool).await?;

    // ON ENTER hooks
    if next == Shipped {
        bus.emit("OrderShipped", order).await;                    // EMIT
        notify_user(pool, order.user_id, &order.tracking_info).await?; // NOTIFY
    }
    if next == Cancelled {
        refund_if_paid(pool, order).await?;                       // TRIGGER
        tracing::info!("Order {} cancelled", order.id);           // LOG
    }
    Ok(())
}

// Generated from LogicScript — STATE Order
#include <unordered_map>, <unordered_set>, <stdexcept>, <string>
#include "db.hpp", "event_bus.hpp", "notification_service.hpp"

enum class OrderStatus { Draft, Pending, Paid, Shipped, Delivered, Cancelled };

class OrderStateMachine {
    using StatusSet = std::unordered_set<OrderStatus>;
    struct Transition { StatusSet from; OrderStatus to; };

    const std::unordered_map<std::string, Transition> transitions_ = {
        {"submitOrder",       {{OrderStatus::Draft},                                       OrderStatus::Pending}},
        {"paymentReceived",   {{OrderStatus::Pending},                                     OrderStatus::Paid}},
        {"fulfillOrder",      {{OrderStatus::Paid},                                        OrderStatus::Shipped}},
        {"deliveryConfirmed", {{OrderStatus::Shipped},                                     OrderStatus::Delivered}},
        {"cancelOrder",       {{OrderStatus::Draft, OrderStatus::Pending,
                                OrderStatus::Paid,  OrderStatus::Shipped},                 OrderStatus::Cancelled}},
    };

public:
    Order& transition(Order& order, const std::string& event) {
        auto it = transitions_.find(event);
        if (it == transitions_.end())
            throw std::invalid_argument("Unknown event: " + event);
        if (!it->second.from.count(order.status))
            throw std::logic_error("Invalid transition via: " + event);

        order.status = it->second.to;
        db_.save(order);

        // ON ENTER hooks
        if (it->second.to == OrderStatus::Shipped) {
            bus_.emit("OrderShipped", order);                    // EMIT
            notif_.notify_user(order.user_id, order.tracking);  // NOTIFY
        }
        if (it->second.to == OrderStatus::Cancelled) {
            refund_if_paid(order);                               // TRIGGER
            std::clog << "Order " << order.id << " cancelled
"; // LOG
        }
        return order;
    }
private:
    Database&            db_;
    EventBus&            bus_;
    NotificationService& notif_;
};