phoenix_gen_api

defmodule PhoenixGenApi.Structs.Request do
  @moduledoc """
  Request struct for internal using, convert data map from websocket api.

  Data from websocket api has payload like this:

  ```Elixir
  %{
    "request_id" => "request_id",
    "request_type" => "request_type",
    "service" => "service",
    "user_id" => "user_id",
    "device_id" => "device_id",
    "args" => %{}
  }
  ```

  We need to convert it to struct for internal using.

  Like this:

  ```Elixir
  %PhoenixGenApi.Structs.Request{
    request_id: "request_id",
    request_type: "request_type",
    service: "service",
    user_id: "user_id",
    device_id: "device_id",
    args: %{}
  }
  ```

  Explain:
  - user_id: string, user's id in system.
    User's id in system. It need to check permission.

  - device_id: string, device id of current connection.
    Device id of current connection.

  - request_type: string, request type.
    Request type. Using for identify function to call in system.

  - request_id: string, unique id for request. Make by client.
    Unique id for request. Make by client. Using for identify response.

  - service: string, service name.
    Service name. Using for identify service to call in system.

  - args: map, field -> value, arguments for request.
    Arguments for request. Using for call function in system.
  """

  alias __MODULE__

  @typedoc "Request struct for internal using, convert data map from websocket api."

  @type t :: %__MODULE__{
          user_id: String.t() | nil,
          device_id: String.t() | nil,
          request_type: String.t(),
          request_id: String.t(),
          service: String.t(),
          args: map(),
          user_roles: [String.t()] | nil,
          version: String.t() | nil
        }

  @derive Nestru.Decoder
  defstruct [
    # string | nil, user's id in system.
    :user_id,
    # string | nil, device id of current connection.
    :device_id,
    # string, request type.
    :request_type,
    # string, unique id for request. Make by client.
    :request_id,
    # string, service name.
    :service,
    # map, field -> value, arguments for request.
    args: %{},
    # list of strings | nil, user roles for permission checking.
    user_roles: nil,
    # string | nil, version of the API request.
    version: nil
  ]

  @doc """
  Create Request from params for convert data map from websocket api.
  """
  def decode!(params = %{}) do
    request = Nestru.decode!(params, Request)

    # set args to empty map if args is nil (function with no args in request)
    request =
      if request.args == nil do
        %{request | args: %{}}
      else
        request
      end

    # validate user_roles is a list of strings if present
    request =
      case request.user_roles do
        nil ->
          request

        roles when is_list(roles) ->
          validated_roles =
            Enum.filter(roles, fn role ->
              is_binary(role) and byte_size(role) > 0
            end)

          %{request | user_roles: validated_roles}

        _ ->
          %{request | user_roles: nil}
      end

    request
  end
end