Hati JSON:API Error

# Three different error formats in one application
class UsersController
  def show
    render json: { error: "User not found" }, status: 404
  end
end

class OrdersController
  def create
    render json: { message: "Validation failed", details: errors }, status: 422
  end
end

class PaymentsController
  def process
    render json: { errors: errors, error_code: "INVALID", status: "failure" }, status: 400
  end
end

raise HatiJsonapiError::UnprocessableEntity.new(
  detail: "Email address is required",
  source: { pointer: "/data/attributes/email" }
)

# Gemfile
gem 'hati-jsonapi-error'

# config/initializers/hati_jsonapi_error.rb
HatiJsonapiError::Config.configure do |config|
  config.load_errors!

  config.map_errors = {
    ActiveRecord::RecordNotFound => :not_found,
    ActiveRecord::RecordInvalid   => :unprocessable_entity,
    ArgumentError                 => :bad_request
  }

  config.use_unexpected = HatiJsonapiError::InternalServerError
end

# Simple error raising
raise HatiJsonapiError::NotFound.new
raise HatiJsonapiError::BadRequest.new
raise HatiJsonapiError::Unauthorized.new

# By class name
raise HatiJsonapiError::NotFound.new

# By status code
api_err = HatiJsonapiError::Helpers::ApiErr
raise api_err[404]

# By error code
raise api_err[:not_found]

HatiJsonapiError::NotFound.new(
  id: 'user_lookup_failed',
  detail: 'User with email john@example.com was not found',
  source: { pointer: '/data/attributes/email' },
  meta: {
    searched_email: 'john@example.com',
    suggestion: 'Verify the email address is correct'
  }
)

errors = []
errors << HatiJsonapiError::UnprocessableEntity.new(
  detail: "Email format is invalid",
  source: { pointer: '/data/attributes/email' }
)
errors << HatiJsonapiError::UnprocessableEntity.new(
  detail: "Password too short",
  source: { pointer: '/data/attributes/password' }
)

resolver = HatiJsonapiError::Resolver.new(errors)
render json: resolver.to_json, status: resolver.status

class ApiController < ApplicationController
  include HatiJsonapiError::Helpers

  rescue_from StandardError, with: :handle_error

  def show
    # ActiveRecord::RecordNotFound automatically mapped to JSON:API NotFound
    user = User.find(params[:id])
    render json: user
  end

  def create
    user = User.new(user_params)

    unless user.save
      validation_error = HatiJsonapiError::UnprocessableEntity.new(
        detail: user.errors.full_messages.join(', '),
        source: { pointer: '/data/attributes' },
        meta: { validation_errors: user.errors.messages }
      )

      return render_error(validation_error)
    end

    render json: user, status: :created
  end
end

class PaymentRequiredError < HatiJsonapiError::PaymentRequired
  def initialize(amount:, currency: 'USD')
    super(
      detail: "Payment of #{amount} #{currency} required",
      meta: {
        required_amount: amount,
        currency: currency,
        payment_methods: ['credit_card', 'paypal']
      },
      links: {
        payment_page: "https://app.com/billing/upgrade?amount=#{amount}"
      }
    )
  end
end

# Usage
raise PaymentRequiredError.new(amount: 29.99)

require 'hati_operation'

class Api::User::CreateOperation < Hati::Operation
  ApiErr = HatiJsonapiError::Helpers::ApiErr

  def call(params)
    user_params = step validate_params(params), err: ApiErr[422]
    user = step create_user(user_params),       err: ApiErr[409]
    profile = step create_profile(user),        err: ApiErr[503]

    Success(profile)
  end

  private

  def validate_params(params)
    return Failure('Invalid parameters') unless params[:name]
    Success(params)
  end
end

HatiJsonapiError::Config.configure do |config|
  config.map_errors = {
    # Rails exceptions
    ActiveRecord::RecordNotFound  => :not_found,
    ActiveRecord::RecordInvalid   => :unprocessable_entity,

    # Custom exceptions
    AuthenticationError           => :unauthorized,
    RateLimitError               => :too_many_requests,

    # Infrastructure exceptions
    Redis::TimeoutError          => :service_unavailable,
    Net::ReadTimeout             => :gateway_timeout
  }

  config.use_unexpected = HatiJsonapiError::InternalServerError
end

# Shared examples for JSON:API compliance
RSpec.shared_examples 'JSON:API error response' do |expected_status, expected_code|
  it 'returns proper JSON:API error format' do
    json = JSON.parse(response.body)

    expect(response).to have_http_status(expected_status)
    expect(json['errors'].first['status']).to eq(expected_status)
    expect(json['errors'].first['code']).to eq(expected_code)
  end
end

# Usage in specs
describe 'GET #show' do
  context 'when user not found' do
    subject { get :show, params: { id: 'nonexistent' } }
    include_examples 'JSON:API error response', 404, 'not_found'
  end
end

RSpec.describe HatiJsonapiError::NotFound do
  it 'has correct default attributes' do
    error = described_class.new

    expect(error.status).to eq(404)
    expect(error.code).to eq(:not_found)
    expect(error.to_h[:title]).to eq('Not Found')
  end
end