I will switch to it by tomorrow 
clifinger
zachdaniel
Creator of Ash
Definitely. No denying it We’ll get it sorted, but likely not in the next few days 
The book has been released into beta, so that’s also a good resource to learn.
0
clifinger
Where I can buy the book ?
Quick question, I tested with
And it work, but something bother me as I need to duplicate the global validations.
Do you have a hint to reuse some validations from resource in another module ?
Maybe it’s more relative to Elixir and my level but I will appreciate if you can help me on this one 
0
clifinger
My frustration got away :
create :register do
argument :password, :string, allow_nil?: false
accept [:email]
validate present(:email), message: "Email must be present"
validate present(:password), message: "Password must be present"
change fn changeset, _ ->
changeset |> maybe_hash_password()
end
end
end
defp maybe_hash_password(changeset) do
password = Ash.Changeset.get_argument(changeset, :password)
if password && changeset.valid? do
changeset
|> Ash.Changeset.change_attribute(:hashed_password, Argon2.hash_pwd_salt(password))
|> Ash.Changeset.clear_change(:password)
else
changeset
end
end
Both Login and register work
0
zachdaniel
Creator of Ash
The book is available here: Ash Framework: Create Declarative Elixir Web Apps by Rebecca Le and Zach Daniel
0
clifinger
zachdaniel
Creator of Ash
Anonymous functions are just one way to define changes/preparations. You can use modules that implement the appropriate behavior.
prepare PreparationModule
....
validate ValidationModule
...
change ChangeModule
In all of those cases you can also add opts to reuse the behavior but customize per use.
change {SomeChange, opt: :value}
You can’t use a change as a preparation or a validation etc. so within those modules if you have to share logic you do it with “regular functions”. I.e if you want a function that takes a string and tells you if it’s a valid email, you can put that in a module alongside your resource and call into it from the resource.
Each of the ways of using those types of modules I mentioned above is explained in its respective guide: Changes — ash v3.29.3
The book also goes into this and how to use/think about it in detail.
0
clifinger
I ended up by:
defmodule VsApp.Accounts.Constants do
@moduledoc """
Centralized constants for account-related validations and messages.
"""
@validation_rules %{
email: %{
regex: ~r/^[\w.+-]+@\w+\.\w+$/,
max_length: 160,
messages: %{
format: "Invalid email format",
length: "Email should have max length of 160",
presence: "Email must be present",
unique: "Email should be unique"
}
},
password: %{
min_length: 6,
messages: %{
length: "Password should have min length of 6",
presence: "Password must be present"
}
}
}
# Getters for validations
def email_regex, do: get_in(@validation_rules, [:email, :regex])
def email_max_length, do: get_in(@validation_rules, [:email, :max_length])
def password_min_length, do: get_in(@validation_rules, [:password, :min_length])
# Getters for messages
def message(:email, key), do: get_in(@validation_rules, [:email, :messages, key])
def message(:password, key), do: get_in(@validation_rules, [:password, :messages, key])
# Validation helper
def valid_email?(email) do
email && is_binary(email) && Regex.match?(email_regex(), email)
end
end
And:
defmodule VsApp.Accounts.Validations.ValidLoginPreparation do
use Ash.Resource.Preparation
require Logger
require Ash.Query
alias VsApp.Accounts.Constants
@impl true
def init(opts), do: {:ok, opts}
@impl true
def prepare(query, _opts, _context) do
password = Ash.Query.get_argument(query, :password)
email = Ash.Query.get_argument(query, :email)
cond do
is_nil(email) or not is_binary(email) ->
Ash.Query.add_error(query, field: :email, message: Constants.message(:email, :presence))
not Regex.match?(Constants.email_regex(), email) ->
Ash.Query.add_error(query, field: :email, message: Constants.message(:email, :format))
String.length(email) > Constants.email_max_length() ->
Ash.Query.add_error(query, field: :email, message: Constants.message(:email, :length))
is_nil(password) or not is_binary(password) ->
Ash.Query.add_error(query,
field: :password,
message: Constants.message(:password, :presence)
)
String.length(password) < Constants.password_min_length() ->
Ash.Query.add_error(query,
field: :password,
message: Constants.message(:password, :length)
)
true ->
query
|> Ash.Query.filter(email == ^email)
|> Ash.Query.load([:hashed_password])
|> Ash.Query.after_action(fn _, user ->
case user do
[user] ->
if Argon2.verify_pass(password, user.hashed_password) do
{:ok, [user]}
else
{:ok, []}
end
[] ->
Argon2.no_user_verify()
{:ok, []}
_ ->
{:ok, []}
end
end)
end
end
end
0
zachdaniel
Creator of Ash
It is on the short list to allow validations to be run against queries, which will make this experience much nicer. i.e validate match(:email, ~r//), message: "..." For now, however, preparations is the only way. Sorry about that!
1