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

That’s a lot to chew on, thanks I’m sure re-reading this in the morning will be fruitful. I can’t wait for the Ash book

There are also docs in each action showing what the action does w/ the changeset given to it: Create Actions — ash v3.29.3

We should enhance the docs here to talk about the way that changes/validations are executed. It’s documented in the changeset functions that run that logic. We should probably but it in module docs or a guide somewhere.

When I said “basic input validation” I mean that we handle the types of each attribute/argument and validate them before setting them. So in the below example, you won’t ever see foo as 10. But the changes still run on an invalid changeset.

Each change and validation is run in the order they appear. When we say that “ypass validations or other action logic”, we’re referring to validations in the action.

Here is an example:

create :create do
  argument :foo, :string, allow_nil?: false

  change fn changeset, _ -> 
    if changeset.arguments[:foo] == "fred" do
      Ash.Changeset.change_attribute(changeset, :is_fred, true)
    else
      changeset
    end
  end

  validate attribute_does_not_equal(:is_fred, true)
end

With the above construction, if you passed in %{foo: "fred"} to the function, it would set is_fred to true, and the validation would fail, because the validation comes after the change.

create :create do
  argument :foo, :string, allow_nil?: false

  change fn changeset, _ ->
    Ash.Changeset.before_action(changeset, fn changeset -> 
      if changeset.arguments[:foo] == "fred" do
        Ash.Changeset.change_attribute(changeset, :is_fred, true)
      else
        changeset
      end
    end)
  end

  validate attribute_does_not_equal(:is_fred, true)
end

With this construction, the order of events looks like this:

1. validate arguments
2. run the change, which adds a hook (to be executed later)
3. run the validation, which doesn’t see the attribute change (because its in a hook to be executed later)
4. return the changeset

So all of the above happens when you do

Ash.Changeset.for_action(Resource, :create, %{foo: "foo"})

In the second example you get back a changeset with a hook on it.

Then it can be passed to Ash.create to actually run the action, which runs any associated hooks.

When using things like AshGraphql or AshJsonApi or code interfaces etc. this is kind of transparent to the caller because it both builds a changeset and runs it on the spot. But Ash actions are actually two phase things, with the idea that phase 1 is cheap and repeatable. If using AshPhoenix.Form for example, each change runs on every keypress because we build the changeset each time.

OK, so change is early on but still post “basic input validation”. Is that different from the validation that the warning was about? Is there somewhere the full sequence of events is documented?

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

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?

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

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

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

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