Hati Rails API

# Gemfile
gem 'hati-rails-api'

# config/contexts/20250121001327_create_user_api.rb
class CreateUserApi < HatiRailsApi::Context::Migration
  def change
    domain :user do |domain|
      domain.operation do |operation|
        operation.component [:create, :update, :delete]
      end
      domain.endpoint true
      domain.model true
      domain.validation
      domain.service
    end
  end
end

# AI can generate this from: "Create an e-commerce API with user management,
# product catalog, and order processing"
class BootstrapEcommerceApi < HatiRailsApi::Context::Migration
  def change
    # User management domain
    domain :user do |domain|
      domain.operation do |operation|
        operation.component [:register, :authenticate, :update_profile]
      end
      domain.endpoint true
      domain.model true
      domain.validation { |v| v.component [:email_validator, :password_validator] }
      domain.service { |s| s.component [:auth_service, :profile_service] }
    end

    # Product catalog domain
    domain :product do |domain|
      domain.operation do |operation|
        operation.component [:create, :update, :search, :categorize]
      end
      domain.endpoint true
      domain.model true
      domain.query { |q| q.component [:product_finder, :category_filter] }
      domain.service { |s| s.component [:inventory_service, :pricing_service] }
    end

    # Order processing domain
    domain :order do |domain|
      domain.operation do |operation|
        operation.component [:create, :process_payment, :fulfill, :cancel]
        operation.step true, granular: true
      end
      domain.endpoint true
      domain.model true
      domain.validation { |v| v.component [:payment_validator, :inventory_validator] }
      domain.service { |s| s.component [:payment_gateway, :shipping_service] }
    end

    # Additional models and endpoints
    model [:cart, :payment, :shipping_address, :order_item]
    endpoint [:order_status, :payment_webhook, :inventory_alert]
  end
end

# AI analyzes existing user and product domains, then adds:
class AddRecommendationSystem < HatiRailsApi::Context::Migration
  def change
    domain :recommendation do |domain|
      domain.operation do |operation|
        operation.component [:generate_recommendations, :track_interactions, :update_preferences]
      end
      domain.service do |service|
        service.component [:ml_engine, :preference_analyzer, :collaborative_filter]
      end
      domain.query { |q| q.component [:recommendation_finder, :interaction_tracker] }
    end

    # Extend existing domains with recommendation capabilities
    extend_domain :user do |domain|
      domain.service { |s| s.add_component :recommendation_service }
    end

    extend_domain :product do |domain|
      domain.query { |q| q.add_component :recommendation_query }
    end
  end
end

# AI generates test migrations alongside feature migrations
class GenerateTestingInfrastructure < HatiRailsApi::Context::Migration
  def change
    testing_domain :api_integration do |domain|
      domain.test_suite do |suite|
        suite.component [:endpoint_tests, :authentication_tests, :authorization_tests]
        suite.coverage :comprehensive
        suite.mock_external_services true
      end
    end

    testing_domain :performance do |domain|
      domain.benchmark do |benchmark|
        benchmark.component [:response_time, :throughput, :memory_usage]
        benchmark.scenarios [:normal_load, :peak_load, :stress_test]
      end
    end
  end
end

class GenerateDeploymentConfig < HatiRailsApi::Context::Migration
  def change
    deployment_domain :infrastructure do |domain|
      domain.container do |container|
        container.component [:api_service, :background_jobs, :database]
        container.scaling :auto
        container.health_checks true
      end

      domain.monitoring do |monitoring|
        monitoring.component [:metrics, :logging, :alerting]
        monitoring.dashboards [:api_performance, :business_metrics, :error_tracking]
      end
    end
  end
end

class CreateAgentToolsApi < HatiRailsApi::Context::Migration
  def change
    domain :agent_tools do |domain|
      # Safe database operations for AI agents
      domain.operation do |operation|
        operation.component [:safe_query, :safe_update, :analyze_data]
        operation.safety_checks true
        operation.audit_logging true
      end

      # AI agent capabilities
      domain.service do |service|
        service.component [:query_builder, :data_analyzer, :report_generator]
        service.rate_limiting true
        service.permission_checking true
      end

      domain.validation { |v| v.component [:query_validator, :safety_checker] }
    end

    # Audit trail for AI operations
    model [:agent_operation_log, :safety_check_result, :permission_audit]
  end
end

class CreateUserApi < HatiRailsApi::Context::Migration
  def change
    domain :user do |domain|
      domain.operation do |operation|
        operation.component [:create, :authenticate, :update_profile]
      end
      domain.endpoint true
      domain.model true
      domain.validation
      domain.serializer
    end
  end
end

class CreateEcommerceApi < HatiRailsApi::Context::Migration
  def change
    domain :ecommerce do |domain|
      # Core business operations
      domain.operation do |operation|
        operation.component [:checkout, :refund, :inventory_check]
        operation.step true, granular: true
      end

      # AI-powered services
      domain.service do |service|
        service.component [:recommendation_engine, :fraud_detector]
      end

      domain.endpoint true
      domain.model true
      domain.validation { |v| v.component [:payment_validator] }
    end

    model [:product, :order, :payment]
    endpoint [:order_status, :payment_webhook]
  end
end

# Custom layers
domain.analytics do |analytics|
  analytics.component [:event_tracker, :report_generator]
end

# Explicit steps
domain.operation do |operation|
  operation.component [:register]
  operation.step :validate, :persist, :notify
end

# Granular steps (uses all domain layers as steps)
domain.operation do |operation|
  operation.step true, granular: true
end

# Generated operation test
RSpec.describe User::Operation::Create do
  describe "#call" do
    it "creates user with valid params" do
      result = described_class.call(valid_user_params)

      expect(result).to be_success
      expect(result.value).to be_a(User)
    end
  end
end

# Generated controller test
RSpec.describe Api::UserController do
  describe "POST /api/users" do
    it "creates user and returns JSON response" do
      post "/api/users", params: valid_params

      expect(response).to have_http_status(:created)
      expect(json_response["data"]["type"]).to eq("user")
    end
  end
end