ash_lua

# SPDX-FileCopyrightText: 2026 ash_lua contributors <https://github.com/ash-project/ash_lua/graphs/contributors>
#
# SPDX-License-Identifier: MIT

defprotocol AshLua.Error do
  @moduledoc """
  Protocol for rendering Ash errors into the Lua-side error shape.

  Each `to_error/1` impl returns a map with these keys (all strings on the Lua side):

    * `:message` — the human-readable message to surface
    * `:short_message` — a terse variant suitable for tooltips/logs
    * `:code` — a stable, machine-readable identifier (e.g. `"invalid_argument"`, `"required"`, `"not_found"`)
    * `:fields` — list of atom field names this error relates to (may be empty)
    * `:vars` — additional template/context variables interpolatable into `message`

  Errors without an impl fall through to an opaque "unknown error" entry in the encoder.
  """
  @fallback_to_any false

  @spec to_error(term()) :: %{
          required(:message) => String.t(),
          required(:short_message) => String.t(),
          required(:code) => String.t(),
          required(:fields) => list(atom()),
          required(:vars) => map()
        }
  def to_error(exception)
end

defimpl AshLua.Error, for: Ash.Error.Changes.InvalidChanges do
  def to_error(error) do
    %{
      message: error.message,
      short_message: error.message,
      vars: Map.new(error.vars),
      code: "invalid_changes",
      fields: List.wrap(error.fields)
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Query.InvalidQuery do
  def to_error(error) do
    fields = List.wrap(error.field || Map.get(error, :fields) || [])

    %{
      message: error.message,
      short_message: error.message,
      vars: Map.new(error.vars),
      code: "invalid_query",
      fields: fields
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Page.InvalidKeyset do
  def to_error(error) do
    %{
      message: "Invalid value provided as a keyset for %{key}: %{value}",
      short_message: "invalid keyset",
      code: "invalid_keyset",
      vars: Map.merge(Map.new(error.vars), %{value: inspect(error.value), key: error.key}),
      fields: List.wrap(Map.get(error, :key))
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Changes.InvalidAttribute do
  def to_error(error) do
    %{
      message: error.message,
      short_message: error.message,
      code: "invalid_attribute",
      vars: Map.new(error.vars),
      fields: [error.field]
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Changes.InvalidArgument do
  def to_error(error) do
    %{
      message: error.message,
      short_message: error.message,
      code: "invalid_argument",
      vars: Map.new(error.vars),
      fields: [error.field]
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Query.InvalidArgument do
  def to_error(error) do
    %{
      message: error.message,
      short_message: error.message,
      code: "invalid_argument",
      vars: Map.new(error.vars),
      fields: [error.field]
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Action.InvalidArgument do
  def to_error(error) do
    %{
      message: error.message,
      short_message: error.message,
      code: "invalid_argument",
      vars: Map.new(error.vars),
      fields: [error.field]
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Changes.Required do
  def to_error(error) do
    %{
      message: "is required",
      short_message: "is required",
      code: "required",
      vars: error.vars,
      fields: [error.field]
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Query.NotFound do
  def to_error(error) do
    %{
      message: "could not be found",
      short_message: "could not be found",
      code: "not_found",
      fields: Map.keys(error.primary_key || %{}),
      vars: error.vars
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Query.Required do
  def to_error(error) do
    %{
      message: "is required",
      short_message: "is required",
      code: "required",
      vars: error.vars,
      fields: [error.field]
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Forbidden.Policy do
  def to_error(error) do
    message =
      if Application.get_env(:ash_lua, :policies)[:show_policy_breakdowns?] || false do
        Ash.Error.Forbidden.Policy.report(error, help_text?: false)
      else
        "forbidden"
      end

    %{
      message: message,
      short_message: "forbidden",
      vars: Map.new(error.vars),
      code: "forbidden",
      fields: []
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Forbidden.ForbiddenField do
  def to_error(_error) do
    %{
      message: "forbidden field",
      short_message: "forbidden field",
      vars: %{},
      code: "forbidden_field",
      fields: []
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Query.ReadActionRequiresActor do
  def to_error(_error) do
    %{
      message: "forbidden",
      short_message: "forbidden",
      vars: %{},
      code: "forbidden",
      fields: []
    }
  end
end

defimpl AshLua.Error, for: Ash.Error.Invalid.InvalidPrimaryKey do
  def to_error(error) do
    %{
      message: "invalid primary key provided",
      short_message: "invalid primary key provided",
      fields: [],
      code: "invalid_primary_key",
      vars: Map.new(error.vars)
    }
  end
end

if Code.ensure_loaded?(AshAuthentication.Errors.AuthenticationFailed) do
  defimpl AshLua.Error, for: AshAuthentication.Errors.AuthenticationFailed do
    def to_error(_error) do
      %{
        message: "Authentication failed",
        short_message: "Authentication failed",
        fields: [],
        code: "authentication_failed",
        vars: %{}
      }
    end
  end
end

if Code.ensure_loaded?(AshAuthentication.Errors.InvalidToken) do
  defimpl AshLua.Error, for: AshAuthentication.Errors.InvalidToken do
    def to_error(_error) do
      %{
        message: "An invalid token was presented",
        short_message: "Invalid token",
        fields: [],
        code: "invalid_token",
        vars: %{}
      }
    end
  end
end