How to make dynamic validations, & ref attributes from inside validation?

Ash Forum Ash Questions / Help
, ,
1

I’m trying to set up a couple of validations – unclear what the best approach is:

    attribute :allowed_types, {:array, :atom} do
      allow_nil? false
      default [:value_add, :non_value_add]
    end

    attribute :default_type, :atom do
      allow_nil? false
    end

  validations do
    # this works but is clunky (what if allowed set is > 2?)
    validate one_of(:allowed_types, [[:value_add, :non_value_add], [:value_add], [:non_value_add]])
    # this doesn't work ... :allowed_types is supposed to be an attribute, not an atom... :/
    validate one_of(:default_type, [:allowed_types])
  end

Potentially pretty obvious, but the intention of the two validations:

  1. The first is to make sure the :allowed_types conforms to some combination of one or more of a set (currently, just [:value_add, :non_value_add])
  2. The second is to make sure that the value of :default_type is one of the types specified in the attribute :allowed_types

I can live with #1 for now (until the list grows, but then it becomes a problem). #2 seems like it may require a custom validation, but I’m unsure if that’s correct… or how to write one quite yet…

2

edit – I realized what I pasted in last night was a complete mess. Updated below.

I came up with a custom validation, and a refinement (but it still doesn’t work quite right):

  @allowed_types [:value_add, :non_value_add]

  ...
  validations do
    validate attribute_in(:allowed_types, @allowed_types)
    validate {TypesAreAllowed, attribute: :default_type}
   end
end

defmodule COE.Walk.ActivityStereotype.Validations.TypesAreAllowed do
  @moduledoc """
  Custom validator that checks to make sure a list of types includes one or more values from @allowed_types.
  """

  @spec init(nil | maybe_improper_list() | map()) ::
          {:error, <<_::208>>} | {:ok, nil | maybe_improper_list() | map()}
  def init(opts) do
    if is_atom(opts[:attribute]), do: {:ok, opts}, else: {:error, "attribute must be an atom!"}
  end

  def validate(changeset, opts) do
    value = Ash.Changeset.get_attribute(changeset, opts[:attribute])
    allowed_types = Ash.Changeset.get_attribute(changeset, :allowed_types)

    #if value != nil && Enum.all?(value, &(&1 in allowed_types)) do
    if value != nil && value in allowed_types do
      :ok
    else
      {:error, field: opts[:attribute], message: "allowed types must be one of #{allowed_types}"}
    end
  end
end

Seems like a reasonable implementation – but if there is something more concise, please do point it out. Thanks!

3

You can use the constraints on the :atom type to do this, or an Ash.Type.Enum

With an enum type:

defmodule YourApp.Types.AllowedWhateverTypes do
  use Ash.Type.Enum, values: ~w(value_add non_value_add)a
end


attributes do
  attribute :allowed_types, {:array, YourApp.Types.AllowedWhateverTypes} do
    allow_nil? false
  end

  attribute :default_type, YourApp.Types.AllowedWhateverTypes do
    allow_nil? false
  end
end

With constraints:

@allowed_types ~w(value_add non_value_add)a

attributes do
  attribute :allowed_types, {:array, :atom} do
    constraints items: [one_of: @allowed_types]
    allow_nil? false
  end

  attribute :default_type, :atom do
    constraints one_of: @allowed_types
    allow_nil? false
  end
end
1 Like
4

Thanks for the different approaches - very useful!

One more question though…

What if :allowed_types is itself an attribute of the type? In other words, I can set the allowable types on the entity with a call like this:

# .create(:name, :allowed_types)
ActivityStereotype.create("Meetings", [:one_on_one, :team, :board_room])

And now I want to make sure that if the :default_type is also set (on the same entity) it must be one of the types allowed when I created the entity. See it’s self-referential. First you set the allowed types, then you make sure the default type is one of the allowed types.

# .create(:name, :allowed_types, :default_type)
ActivityStereotype.create("Meetings", [:one_on_one, :team, :board_room], :team)

I’m having some trouble getting the bit that says “given a new :default_type, check to make sure it’s one of the :allowed_types that I just provided”.

My solution is this custom validator, but it seems a bit hardcoded.

defmodule COE.Walk.ActivityStereotype.Validations.TypesAreAllowed do
  @moduledoc """
  Custom validator that checks to make sure a list of types includes one or more values from @allowed_types.
  """

  def init(opts) do
    if is_atom(opts[:attribute]), do: {:ok, opts}, else: {:error, "attribute must be an atom!"}
  end

  def validate(changeset, opts) do
    value = Ash.Changeset.get_attribute(changeset, opts[:attribute])
    allowed_types = Ash.Changeset.get_attribute(changeset, :allowed_types)

    #if value != nil && Enum.all?(value, &(&1 in allowed_types)) do
    if value != nil && value in allowed_types do
      :ok
    else
      {:error, field: opts[:attribute], message: "allowed types must be one of #{allowed_types}"}
    end
  end
end

My very first attempt (which did not work) was:

  validations do
    validate attribute_in(:default_type, :allowed_types)
  end

And it just seemed like there ought to be a simple solution to this that I haven’t discovered yet (beyond the custom validator).