class Order::Place < Dex::Operation
  prop :customer, _Ref(Customer)
  prop :product, _Ref(Product)
  prop :quantity, _Integer(1..)
  prop? :note, String

  success _Ref(Order)
  error :out_of_stock

  def perform
    error!(:out_of_stock) unless product.in_stock?

    order = Order.create!(customer: customer, product: product, quantity: quantity, note: note)

    after_commit { Order::Placed.publish(order_id: order.id, total: order.total) }

    order
  end
end

order = Order::Place.call(customer: 42, product: 7, quantity: 2)
order.id  # => 1

prop :quantity, _Integer(1..)
prop :currency, _Union("USD", "EUR", "GBP")
prop :customer, _Ref(Customer)        # accepts Customer instance or ID
prop? :note, String                    # optional (nil by default)

product = assert!(:not_found) { Product.find_by(id: product_id) }

rescue_from Stripe::CardError, as: :payment_declined

case Order::Place.new(customer: 42, product: 7, quantity: 2).safe.call
in Ok => result
  redirect_to order_path(result.id)
in Err(code: :out_of_stock)
  flash[:error] = "Product is out of stock"
end

Order::Fulfill.new(order_id: 123).async(queue: "fulfillment").call

class Payment::Charge < Dex::Operation
  prop :order_id, Integer
  prop :amount, Integer

  once :order_id                          # key from prop
  # once :order_id, :merchant_id          # composite key
  # once                                  # all props as key
  # once { "custom-#{order_id}" }         # block-based key
  # once :order_id, expires_in: 24.hours  # expiring key

  def perform
    Gateway.charge!(order_id, amount)
  end
end

# Call-site key (overrides class-level declaration)
Payment::Charge.new(order_id: 1, amount: 500).once("ext-key-123").call

# Bypass once guard for a single call
Payment::Charge.new(order_id: 1, amount: 500).once(nil).call

# Clear a stored key to allow re-execution
Payment::Charge.clear_once!(order_id: 1)

guard :out_of_stock, "Product must be in stock" do
  !product.in_stock?
end

# In a view or controller:
Order::Place.callable?(customer: customer, product: product, quantity: 1)

class Order::Place < Dex::Operation
  prop :product, _Ref(Product)
  prop :customer, _Ref(Customer)
  context customer: :current_customer   # filled from Dex.context[:current_customer]

  def perform
    Order.create!(product: product, customer: customer)
  end
end

# Controller
Dex.with_context(current_customer: current_customer) do
  Order::Place.call(product: product)   # customer auto-filled
end

# Tests – just pass it explicitly
Order::Place.call(product: product, customer: customer)

class PlaceOrderTest < Minitest::Test
  testing Order::Place

  def test_places_order
    assert_operation(customer: customer.id, product: product.id, quantity: 2)
  end

  def test_rejects_out_of_stock
    assert_operation_error(:out_of_stock, customer: customer.id,
      product: out_of_stock_product.id, quantity: 1)
  end
end

class Order::Placed < Dex::Event
  prop :order_id, Integer
  prop :total, BigDecimal
  prop? :coupon_code, String
end

class NotifyWarehouse < Dex::Event::Handler
  on Order::Placed
  retries 3

  def perform
    WarehouseApi.notify(event.order_id)
  end
end

Order::Placed.publish(order_id: 1, total: 99.99)

order_placed.trace do
  Shipment::Reserved.publish(order_id: 1)
end

class PlaceOrderTest < Minitest::Test
  include Dex::Event::TestHelpers

  def test_publishes_order_placed
    capture_events do
      Order::Place.call(customer: customer.id, product: product.id, quantity: 2)
      assert_event_published(Order::Placed)
    end
  end
end

class Employee::Form < Dex::Form
  model Employee

  attribute :first_name, :string
  attribute :last_name, :string
  attribute :email, :string

  normalizes :email, with: -> { _1&.strip&.downcase.presence }

  validates :email, presence: true, uniqueness: true
  validates :first_name, :last_name, presence: true

  nested_one :address do
    attribute :street, :string
    attribute :city, :string
    validates :street, :city, presence: true
  end
end

form = Employee::Form.new(email: "  ALICE@EXAMPLE.COM  ", first_name: "Alice", last_name: "Smith")
form.email  # => "alice@example.com"
form.valid?

nested_many :emergency_contacts do
  attribute :name, :string
  attribute :phone, :string
  validates :name, :phone, presence: true
end

def save
  return false unless valid?

  case operation.safe.call
  in Ok then true
  in Err => e then errors.add(:base, e.message) and false
  end
end

class Order::Query < Dex::Query
  scope { Order.all }

  prop? :status, String
  prop? :customer, _Ref(Customer)
  prop? :total_min, Integer

  filter :status
  filter :customer
  filter :total_min, :gte, column: :total

  sort :created_at, :total, default: "-created_at"
end

orders = Order::Query.call(status: "pending", sort: "-total")

class OrdersController < ApplicationController
  def index
    query = Order::Query.from_params(params, scope: policy_scope(Order))
    @orders = pagy(query.resolve)
  end
end

gem "dexkit"