Best fix for "Changeset has already been validated for action" warning

Do the before action hooks you’re using have side effects/do anything expensive? If not your best bet is to to just move the code into the body of the cnange.

Alternatively for actions that have to set values in before_action hooks you can set the validations to be done themselves in before action hooks with before_action?: true

Then they will happen after your logic to change attributes despite that logic being in a before_action hook

No, at worst they might lazy load something, for the most part it’s things like the run_mode attribute depends on the type of another argument.

Right, so in that case there is likely no need for a before_action hook at all.

i.e

def change(changeset, _, _) do
  Ash.Changeset.before_action(changeset, fn changeset, _ -> 
    if changeset.arguments.whatever == "foo" do
      Ash.Changeset.change_attribute(changeset, :is_foo, true)
    else
      changeset
    end
  end)
end

can be

def change(changeset, _, _) do
  if changeset.arguments[:whatever] == "foo" do
    Ash.Changeset.change_attribute(changeset, :is_foo, true)
  else
    changeset
  end
end

The major difference you may notice is that the body of changes runs on both valid and invalid change sets, so you may want to add change YourChange, only_when_valid?: true, or an if changeset.valid? in your change implementation, or simply handle the fact that the changes may be invalid (so don’t rely on something like changeset.arguments.whatever, instead use Ash.Changeset.get_argument(changeset, :whatever), and be aware that it can be invalid.

This is good though as it allows knowing up front an action will fail and producing multiple errors at a time.

I guess that only works with custom actions each in their own module? At the moment they are all just create and update actions within the resource modules.

I noticed that the example for a custom action uses force_change_attribute anyway: Changes — ash v3.29.3

I’m not sure what you mean. Do you mean that the changes are all in anonymous functions? You can put them in change modules that use Ash.Resource.Change

All my actions are of the form:

actions do
  create :create do
    accept [:foo]
    argument :whatever, :integer
    change before_action(fn changeset, _ ->
      if Ash.Changeset.get_argument(changeset, :whatever) > 0 do
        Ash.Changeset.change_attribute(changeset, :foo, "positive")
      else
        changeset  
      end  
    end)
  end
end

To keep that form

actions do
  create :create do
    accept [:foo]
    argument :whatever, :integer
    change fn changeset, _ ->
      if Ash.Changeset.get_argument(changeset, :whatever) > 0 do
        Ash.Changeset.change_attribute(changeset, :foo, "positive")
      else
        changeset  
      end  
    end
  end
end

That’s a bit confusing - the warning is about calling change_attribute in a change before_action, which is post validation. Isn’t change even more post validation?

Nope. Change happens first. It’s the very first thing that happens. It happens on every valid

The general formula looks like this:

defmodule AChange do
  use Ash.Resource.Change


  def change(changeset, opts, context) do
    changeset
    |> Ash.Changeset.before_action(fn changeset ->
      # does something before the action is invoked
    end)
    |> Ash.Changeset.after_action(fn changeset, result ->
      # does something after
    end)
    |> …other hooks or modifications
  end
end

Anything that you do in the change function happens at the very beginning after basic input validation, when you run functions like Ash.Changeset.for_create(…).

change before_action(function) is just a built in shorthand that looks like this

defmodule BeforeAction do
  use Ash.Resource.Change

  def change(changeset, opts, context) do
    Ash.Changeset.before_action(changeset, fn changeset ->
      opts[:function].(changeset, context)
    end)
  end
end