gem 'restate-sdk-ruby'

require 'restate'

# Basic stateless service
class Greeter < Restate::BasicService
  handler :greet
  def greet(input)
    name = input["name"]
    "Hello, #{name}!"
  end
end

Restate.configure do |config|
  config.bind = "http://localhost:4100"
  config.ingress_url = "http://localhost:8080"
  config.admin_url = "http://localhost:9070"
end

Restate.endpoint.define do
  mount Greeter
end

# config.ru
require 'restate'
require_relative 'services'

run Restate.endpoint.to_rack_app

#!/usr/bin/env -S falcon host
# config/falcon.rb

require 'falcon/environment/server'
require 'restate'
require_relative 'services'

service "restate" do
  include Falcon::Environment::Server
  
  count 1
  url { "http://localhost:4100" }
  
  middleware do
    Falcon::Server.middleware(Restate.endpoint.to_rack_app, verbose:, cache:)
  end
end

# From within another Restate handler (durable)
result = Greeter.call.greet(name: "World")

# From outside Restate (using HTTP client)
result = Restate.client.service("Greeter").greet(name: "World")

class EmailService < Restate::BasicService
  handler :send_email
  def send_email(input)
    to = input["to"]
    subject = input["subject"]
    
    # Durable execution - only runs once even on retries
    run("send_via_api") do
      EmailAPI.send(to: to, subject: subject)
    end
  end
end

class Counter < Restate::VirtualObject
  state :count, Integer, default: 0
  
  # Exclusive handler - can mutate state
  handler :increment
  def increment(amount = 1)
    self.count += amount
    count
  end
  
  # Shared handler - read-only, concurrent access
  shared :get
  def get
    count
  end
end

# Invoke with a key
Counter.call("user-123").increment(5)
value = Counter.call("user-123").get

class OrderWorkflow < Restate::Workflow
  state :status, String, default: "pending"
  
  # Main workflow entrypoint
  def run(input)
    order_id = input["order_id"]
    
    # Wait for external confirmation
    payment = promise("payment").value
    
    self.status = "processing"
    
    # Call other services durably
    InventoryService.call.reserve(order_id: order_id)
    ShippingService.call.ship(order_id: order_id)
    
    self.status = "completed"
  end
  
  # Shared handlers for querying/completing
  shared :get_status
  def get_status
    status
  end
  
  shared :confirm_payment
  def confirm_payment(payment_info)
    promise("payment").resolve(payment_info)
  end
end

# Start workflow
OrderWorkflow.send("order-123").run(order_id: "order-123")

# Query status
status = OrderWorkflow.call("order-123").get_status

# Complete payment
OrderWorkflow.call("order-123").confirm_payment(amount: 100)

handler :process
def process(input)
  # Result is journaled - block only runs once
  api_result = run("fetch_data") do
    ExternalAPI.fetch(input["id"])
  end
  
  # Process the result
  process_data(api_result)
end

# Sleep for 30 seconds
sleep(30)

# Or use a Time object
sleep_until(Time.now + 1.hour)

# Call another service and wait
result = OtherService.call.method_name(input)

# Send one-way (fire and forget)
OtherService.send.method_name(input)

# Send with delay
OtherService.send(after: 1.hour).method_name(input)

# Call with idempotency key
OtherService.call.idempotency_key("unique-id").method_name(input)

handler :start_task
def start_task(input)
  awakeable = awakeable
  
  # Send awakeable ID to external system
  ExternalQueue.enqueue(awakeable_id: awakeable.id, task: input)
  
  # Wait for external completion
  result = awakeable.value
  result
end

Restate.client.resolve_awakeable(awakeable_id, payload)

Restate.configure do |config|
  # Local endpoint binding (where this service listens)
  config.bind = "http://localhost:4100"
  
  # URL Restate uses to reach this endpoint
  config.advertise_url = "http://host.docker.internal:4100"
  
  # Restate ingress URL (for invoking services)
  config.ingress_url = "http://localhost:8080"
  
  # Restate admin API URL (for registration)
  config.admin_url = "http://localhost:9070"
  
  # Auto-register on startup
  config.create_deployment_on_start = true
  
  # Identity verification keys (optional)
  config.identity_keys = ["your-signing-key"]
  
  # Custom JSON serializer (defaults to Oj)
  config.default_json_serializer = CustomSerializer
end

middleware = Restate::MiddlewareStack.new
middleware.use Rack::CommonLogger
middleware.use MyCustomMiddleware, option: "value"

app = middleware.build(Restate.endpoint.to_rack_app)
run app

# config/initializers/restate.rb
Restate.configure do |config|
  config.bind = "http://localhost:#{ENV.fetch('RESTATE_ENDPOINT_PORT', 4100)}"
  config.ingress_url = ENV.fetch("RESTATE_INGRESS_URL", "http://localhost:8080")
  config.admin_url = ENV.fetch("RESTATE_ADMIN_URL", "http://localhost:9070")
  config.create_deployment_on_start = Rails.env.development?
end

# config/services.rb
Restate.endpoint.define do
  mount Greeter
  mount Counter
  mount OrderWorkflow
end