defmodule Ash.CodeInterface do
@moduledoc """
Used to define the functions of a code interface for a resource.
"""
@doc false
def require_action(resource, interface) do
action = Ash.Resource.Info.action(resource, interface.action || interface.name)
unless action do
raise Spark.Error.DslError,
module: resource,
message:
"The interface of #{inspect(resource)} refers to a non-existent action #{interface.action || interface.name}",
path: [:interfaces, :interface, interface.name]
end
action
end
@doc false
def default_value(resource, action, key) do
{field_type, field} =
case Enum.find(action.arguments, fn argument ->
argument.name == key
end) do
nil ->
{:attribute, Ash.Resource.Info.attribute(resource, key)}
argument ->
{:argument, argument}
end
cond do
field.allow_nil? && !(field.name in Map.get(action, :require_attributes, [])) ->
:ok
field.name in Map.get(action, :allow_nil_input, []) ->
:ok
!(field.name in Map.get(action, :accept, [])) ->
:ok
true ->
raise "Code interface for #{action.name} has optional argument #{key} but it is not optional"
end
default =
if field_type == :argument do
field.default
else
if action.type == :update || (action.type == :destroy && action.soft?) do
if is_nil(field.update_default) do
field.default
else
field.update_default
end
else
field.default
end
end
if is_function(default) do
quote do
unquote(Macro.escape(default)).()
end
else
quote do
unquote(Macro.escape(default))
end
end
end
def without_optional(keys) do
Enum.map(keys, fn
{:optional, key} ->
key
key ->
key
end)
end
def unwrap_calc_interface_args(keys, resource, arguments, function_head? \\ false) do
{Enum.map(keys, &unwrap_calc_interface_arg_binding(resource, arguments, &1, function_head?)),
Enum.map(keys, &unwrap_calc_interface_arg_access(&1))}
end
defp unwrap_calc_interface_arg_access({:optional, value}),
do: unwrap_calc_interface_arg_access(value)
defp unwrap_calc_interface_arg_access({:optional, value, _}),
do: unwrap_calc_interface_arg_access(value)
defp unwrap_calc_interface_arg_access(value) do
case value do
:_record ->
[type: :_record, name: :record, value: {:record, [], Elixir}]
{tag, name} ->
[type: tag, name: name, value: {name, [], Elixir}]
name ->
[type: :both, name: name, value: {name, [], Elixir}]
end
end
defp unwrap_calc_interface_arg_binding(resource, arguments, {:optional, binding}, head?) do
access = unwrap_calc_interface_arg_binding(resource, arguments, binding, head?)
if head? do
{:\\, [], [access, default_calc_value(resource, arguments, binding)]}
else
access
end
end
defp unwrap_calc_interface_arg_binding(
resource,
arguments,
{:optional, binding, default},
head?
) do
access = unwrap_calc_interface_arg_binding(resource, arguments, binding, head?)
if head? do
{:\\, [], [access, default]}
else
access
end
end
defp unwrap_calc_interface_arg_binding(_resource, _arguments, {tag, value}, _)
when tag in [:arg, :ref] do
{value, [], Elixir}
end
defp unwrap_calc_interface_arg_binding(resource, _arguments, :_record, false) do
{:=, [],
[
{:%, [], [{:__aliases__, [alias: false], [resource]}, {:%{}, [], []}]},
{:record, [], Elixir}
]}
end
defp unwrap_calc_interface_arg_binding(_resource, _arguments, value, _) do
{value, [], Elixir}
end
@doc false
def default_calc_value(_resource, arguments, {:arg, arg_name}) do
arguments
|> Enum.find(&(&1.name == arg_name))
|> case do
nil ->
nil
argument ->
argument.default
end
end
def default_calc_value(resource, _, {:ref, attribute}) do
resource
|> Ash.Resource.Info.attributes()
|> Enum.find(&(&1.name == attribute))
|> case do
nil ->
nil
attribute ->
attribute.default
end
end
def default_calc_value(resource, arguments, name) do
case default_calc_value(resource, arguments, {:arg, name}) do
nil ->
default_calc_value(resource, arguments, {:ref, name})
value ->
value
end
end
@doc false
# sobelow_skip ["DOS.BinToAtom", "DOS.StringToAtom"]
def resolve_calc_method_names(name) do
if name |> to_string() |> String.ends_with?("?") do
safe_name = name |> to_string() |> String.trim_trailing("?") |> String.to_atom()
bang_name = name
{safe_name, bang_name}
else
safe_name = name
bang_name = "#{name}!" |> String.to_atom()
{safe_name, bang_name}
end
end
@doc """
Defines the code interface for a given resource + domain combination in the current module. For example:
```elixir
defmodule MyApp.Accounting do
require Ash.CodeInterface
Ash.CodeInterface.define_interface(MyApp.Accounting, MyApp.Accounting.Transaction)
Ash.CodeInterface.define_interface(MyApp.Accounting, MyApp.Accounting.Account)
Ash.CodeInterface.define_interface(MyApp.Accounting, MyApp.Accounting.Invoice)
end
```
"""
defmacro define_interface(domain, resource, definitions \\ nil) do
quote bind_quoted: [domain: domain, resource: resource, definitions: definitions],
generated: true,
location: :keep do
calculation_interfaces =
case definitions do
nil ->
Ash.Resource.Info.calculation_interfaces(resource)
definitions ->
Enum.filter(definitions, &match?(%Ash.Resource.CalculationInterface{}, &1))
end
interfaces =
case definitions do
nil ->
Ash.Resource.Info.interfaces(resource)
definitions ->
Enum.filter(definitions, &match?(%Ash.Resource.Interface{}, &1))
end
interfaces_for_defaults =
Enum.group_by(calculation_interfaces, fn interface ->
{interface.name, Enum.count(interface.args, &is_atom/1), Enum.count(interface.args)}
end)
for {{name, arity, optional_arity}, interfaces} <- interfaces_for_defaults do
args =
case interfaces do
[%{args: args, calculation: calculation}] ->
calculation = Ash.Resource.Info.calculation(resource, calculation)
{arg_bindings, _arg_access} =
args
|> Kernel.||([])
|> Ash.CodeInterface.unwrap_calc_interface_args(
resource,
calculation.arguments,
true
)
arg_bindings
multiple ->
multiple
|> Enum.map(fn interface ->
interface.args
|> Enum.flat_map(fn
{:optional, value} ->
calculation = Ash.Resource.Info.calculation(resource, interface.calculation)
[Ash.CodeInterface.default_calc_value(resource, calculation.arguments, value)]
{:optional, _, value} ->
[value]
_ ->
[]
end)
end)
|> Enum.uniq()
|> case do
[_] ->
interface = hd(multiple)
calculation = Ash.Resource.Info.calculation(resource, interface.calculation)
{arg_bindings, _arg_access} =
interface.args
|> Kernel.||([])
|> Ash.CodeInterface.unwrap_calc_interface_args(
resource,
calculation.arguments,
true
)
arg_bindings
_duplicates ->
raise """
The generated function #{name}/#{arity + optional_arity} would have
multiple different sets of default values for arguments. Please use a different
name for conflicting code interface functions.
"""
end
end
{safe_name, bang_name} = Ash.CodeInterface.resolve_calc_method_names(name)
def unquote(bang_name)(unquote_splicing(args), opts \\ [])
def unquote(safe_name)(unquote_splicing(args), opts \\ [])
end
for interface <- calculation_interfaces do
calculation = Ash.Resource.Info.calculation(resource, interface.calculation)
{arg_bindings, arg_access} =
interface.args
|> Kernel.||([])
|> Ash.CodeInterface.unwrap_calc_interface_args(resource, calculation.arguments)
{safe_name, bang_name} = Ash.CodeInterface.resolve_calc_method_names(interface.name)
opts_location = Enum.count(arg_bindings)
interface_options = Ash.Resource.Interface.interface_options(:calculate, nil)
@doc """
#{calculation.description || "Calculates #{calculation.name} action on #{inspect(resource)}."}
#{Ash.CodeInterface.describe_calculation(resource, calculation, interface.args)}
### Options
#{interface_options.docs()}
"""
|> Ash.CodeInterface.trim_double_newlines()
@doc spark_opts: [
{opts_location, interface_options.schema()}
]
def unquote(bang_name)(unquote_splicing(arg_bindings), opts) do
{refs, arguments, record} =
Enum.reduce(
[unquote_splicing(arg_access)],
{%{}, %{}, nil},
fn config, {refs, arguments, record} ->
case config[:type] do
:_record ->
{refs, arguments, config[:value]}
:both ->
{Map.put(refs, config[:name], config[:value]),
Map.put(arguments, config[:name], config[:value]), record}
:ref ->
{Map.put(refs, config[:name], config[:value]), arguments, record}
:arg ->
{refs, Map.put(arguments, config[:name], config[:value]), record}
end
end
)
opts = [domain: unquote(domain), refs: refs, args: arguments, record: record] ++ opts
Ash.calculate!(unquote(resource), unquote(interface.calculation), opts)
end
@doc """
#{calculation.description || "Calculates #{calculation.name} action on #{inspect(resource)}."}
#{Ash.CodeInterface.describe_calculation(resource, calculation, interface.args)}
### Options
#{interface_options.docs()}
"""
|> Ash.CodeInterface.trim_double_newlines()
@doc spark_opts: [
{opts_location, interface_options.schema()}
]
def unquote(safe_name)(unquote_splicing(arg_bindings), opts) do
{refs, arguments, record} =
Enum.reduce(
[unquote_splicing(arg_access)],
{%{}, %{}, nil},
fn config, {refs, arguments, record} ->
case config[:type] do
:_record ->
{refs, arguments, config[:value]}
:both ->
{Map.put(refs, config[:name], config[:value]),
Map.put(arguments, config[:name], config[:value]), record}
:ref ->
{Map.put(refs, config[:name], config[:value]), arguments, record}
:arg ->
{refs, Map.put(arguments, config[:name], config[:value]), record}
end
end
)
opts = [domain: unquote(domain), refs: refs, args: arguments, record: record] ++ opts
Ash.calculate(unquote(resource), unquote(interface.calculation), opts)
end
end
for interface <- interfaces do
action = Ash.CodeInterface.require_action(resource, interface)
filter_keys =
cond do
action.type not in [:read, :update, :destroy] ->
[]
interface.get_by_identity ->
Ash.Resource.Info.identity(resource, interface.get_by_identity).keys
interface.get_by ->
interface.get_by
true ->
[]
end
args = List.wrap(filter_keys) ++ Ash.CodeInterface.without_optional(interface.args || [])
arg_vars = Enum.map(args, &{&1, [], Elixir})
arg_vars_function =
filter_keys
|> List.wrap()
|> Enum.concat(interface.args || [])
|> Enum.map(fn
{:optional, key} ->
default = Ash.CodeInterface.default_value(resource, action, key)
{:\\, [], [{key, [], Elixir}, default]}
key ->
{key, [], Elixir}
end)
unless Enum.uniq(args) == args do
raise """
Arguments #{inspect(args)} for #{interface.name} are not unique!
"""
end
interface =
if Map.get(action, :get?) do
%{interface | get?: true}
else
interface
end
interface_options = Ash.Resource.Interface.interface_options(action.type, interface)
resolve_opts_params =
quote do
{params, opts} =
if opts == [] && Keyword.keyword?(params_or_opts),
do:
{%{},
unquote(interface_options).validate!(params_or_opts)
|> unquote(interface_options).to_options()},
else:
{params_or_opts,
unquote(interface_options).validate!(opts)
|> unquote(interface_options).to_options()}
params =
unquote(args)
|> Enum.zip([unquote_splicing(arg_vars)])
|> Enum.reduce(params, fn {key, value}, params ->
Map.put(params, key, value)
end)
end
resolve_bang_opts_params =
quote do
{params, opts} =
if opts == [] && Keyword.keyword?(params_or_opts),
do:
{if(params_or_opts != [], do: %{}, else: []),
unquote(interface_options).validate!(params_or_opts)
|> unquote(interface_options).to_options()},
else:
{if(Keyword.keyword?(params_or_opts),
do: Map.new(params_or_opts),
else: params_or_opts
),
unquote(interface_options).validate!(opts)
|> unquote(interface_options).to_options()}
params =
if is_list(params) do
to_merge =
unquote(args)
|> Enum.zip([unquote_splicing(arg_vars)])
|> Map.new()
Enum.map(params, fn params ->
Map.merge(params, to_merge)
end)
else
unquote(args)
|> Enum.zip([unquote_splicing(arg_vars)])
|> Enum.reduce(params, fn {key, value}, params ->
Map.put(params, key, value)
end)
end
end
{subject, subject_args, resolve_subject, act, act!} =
case action.type do
:action ->
subject = quote do: input
resolve_subject =
quote do
{input_opts, opts} =
Keyword.split(opts, [:input, :actor, :tenant, :authorize?, :tracer])
{input, input_opts} = Keyword.pop(input_opts, :input)
input_opts = Keyword.put(input_opts, :domain, unquote(domain))
case input do
%Ash.ActionInput{resource: unquote(resource)} ->
input
%Ash.ActionInput{resource: other_resource} ->
raise ArgumentError,
"Action input resource #{inspect(other_resource)} does not match expected resource #{inspect(unquote(resource))}."
input ->
input
end
input =
input
|> Kernel.||(unquote(resource))
|> Ash.ActionInput.for_action(unquote(action.name), params, input_opts)
end
act = quote do: Ash.run_action(input, opts)
act! = quote do: Ash.run_action!(input, opts)
{subject, [], resolve_subject, act, act!}
:read ->
subject = quote do: query
resolve_subject =
quote do
{query_opts, opts} =
Keyword.split(opts, [:query, :actor, :tenant, :authorize?, :tracer, :context])
{query, query_opts} = Keyword.pop(query_opts, :query)
query_opts = Keyword.put(query_opts, :domain, unquote(domain))
query =
case query do
%Ash.Query{resource: unquote(resource)} = query ->
query
%Ash.Query{resource: other_resource} ->
raise ArgumentError,
"Query resource #{inspect(other_resource)} does not match expected resource #{inspect(unquote(resource))}."
unquote(resource) ->
unquote(resource)
|> Ash.Query.new()
other_resource
when is_atom(other_resource) and not is_nil(other_resource) ->
raise ArgumentError,
"Query resource #{inspect(other_resource)} does not match expected resource #{inspect(unquote(resource))}."
query ->
Ash.Query.build(unquote(resource), query || [])
end
query =
if unquote(filter_keys) && !Enum.empty?(unquote(filter_keys)) do
require Ash.Query
{filters, params} = Map.split(params, unquote(filter_keys))
query
|> Ash.Query.for_read(unquote(action.name), params, query_opts)
|> Ash.Query.filter(filters)
else
Ash.Query.for_read(query, unquote(action.name), params, query_opts)
end
end
resolve_not_found_error? =
quote do
{not_found_error?, opts} = Keyword.pop(opts, :not_found_error?)
not_found_error? =
if not_found_error? != nil,
do: not_found_error?,
else: unquote(interface.not_found_error?)
end
act =
if interface.get? do
quote do
unquote(resolve_not_found_error?)
Ash.read_one(query, Keyword.drop(opts, [:stream?, :stream_options]))
|> case do
{:ok, nil} when not_found_error? ->
{:error, Ash.Error.Query.NotFound.exception(resource: query.resource)}
result ->
result
end
end
else
quote do: Ash.read(query, Keyword.drop(opts, [:stream?, :stream_options]))
end
act! =
if interface.get? do
quote do
unquote(resolve_not_found_error?)
Ash.read_one!(query, Keyword.drop(opts, [:stream?, :stream_options]))
|> case do
nil when not_found_error? ->
raise Ash.Error.Query.NotFound, resource: query.resource
result ->
result
end
end
else
quote do
if opts[:stream?] do
Ash.stream!(query, Keyword.drop(opts, [:stream?, :stream_options]))
else
Ash.read!(query, Keyword.drop(opts, [:stream?, :stream_options]))
end
end
end
{subject, [], resolve_subject, act, act!}
:create ->
subject = quote do: changeset
resolve_subject =
quote do
{changeset, opts} = Keyword.pop(opts, :changeset)
{changeset_opts, opts} =
Keyword.split(opts, [
:actor,
:tenant,
:authorize?,
:tracer,
:context,
:skip_unknown_inputs
])
changeset_opts = Keyword.put(changeset_opts, :domain, unquote(domain))
changeset =
if is_map(params) do
changeset
|> Kernel.||(unquote(resource))
|> case do
%Ash.Changeset{resource: unquote(resource)} ->
changeset
%Ash.Changeset{resource: other_resource} ->
raise ArgumentError,
"Changeset #{inspect(changeset)} does not match expected resource #{inspect(unquote(resource))}."
other_resource
when is_atom(other_resource) and other_resource != unquote(resource) ->
raise ArgumentError,
"Resource #{inspect(other_resource)} does not match expected resource #{inspect(unquote(resource))}."
changeset ->
changeset
end
|> Ash.Changeset.for_create(unquote(action.name), params, changeset_opts)
else
{:bulk, params}
end
end
act =
quote do
case changeset do
{:bulk, inputs} ->
bulk_opts =
opts
|> Keyword.delete(:bulk_options)
|> Keyword.merge(Keyword.get(opts, :bulk_options, []))
|> Enum.concat(changeset_opts)
Ash.bulk_create(
inputs,
unquote(resource),
unquote(action.name),
bulk_opts
)
changeset ->
Ash.create(changeset, Keyword.delete(opts, :bulk_options))
end
end
act! =
quote do
case changeset do
{:bulk, inputs} ->
bulk_opts =
opts
|> Keyword.delete(:bulk_options)
|> Keyword.merge(Keyword.get(opts, :bulk_options, []))
|> Enum.concat(changeset_opts)
Ash.bulk_create!(
inputs,
unquote(resource),
unquote(action.name),
bulk_opts
)
changeset ->
Ash.create!(changeset, Keyword.delete(opts, :bulk_options))
end
end
{subject, [], resolve_subject, act, act!}
:update ->
subject = quote do: changeset
subject_args =
if interface.require_reference? do
quote do: [record]
else
[]
end
resolve_subject =
if Enum.empty?(filter_keys) and interface.require_reference? do
quote do
{changeset_opts, opts} =
Keyword.split(opts, [
:actor,
:tenant,
:authorize?,
:tracer,
:context,
:skip_unknown_inputs
])
changeset_opts = Keyword.put(changeset_opts, :domain, unquote(domain))
changeset =
record
|> case do
%Ash.Changeset{resource: unquote(resource)} ->
{filters, params} = Map.split(params, unquote(filter_keys))
record
|> Ash.Changeset.filter(filters)
|> Ash.Changeset.for_update(
unquote(action.name),
params,
changeset_opts
)
%Ash.Changeset{resource: other_resource} ->
raise ArgumentError,
"Changeset #{inspect(record)} does not match expected resource #{inspect(unquote(resource))}."
%struct{} = record when struct == unquote(resource) ->
{filters, params} = Map.split(params, unquote(filter_keys))
record
|> Ash.Changeset.new()
|> Ash.Changeset.filter(filters)
|> Ash.Changeset.for_update(
unquote(action.name),
params,
changeset_opts
)
%Ash.Query{} = query ->
{:atomic, :query, query}
%other_resource{} when other_resource != unquote(resource) ->
raise ArgumentError,
"Record #{inspect(record)} does not match expected resource #{inspect(unquote(resource))}."
[{_key, _val} | _] = id ->
{:atomic, :id, id}
list when is_list(list) ->
{:atomic, :stream, list}
other ->
{:atomic, :id, other}
end
end
else
quote do
filters = Map.take(params, unquote(filter_keys))
{changeset_opts, opts} =
Keyword.split(opts, [
:actor,
:tenant,
:authorize?,
:tracer,
:context,
:skip_unknown_inputs
])
changeset_opts = Keyword.put(changeset_opts, :domain, unquote(domain))
changeset =
{:atomic, :query, Ash.Query.do_filter(unquote(resource), filters)}
end
end
act =
quote do
{filters, params} = Map.split(params, unquote(filter_keys))
case changeset do
{:atomic, method, id} ->
bulk_opts =
opts
|> Keyword.drop([:bulk_options, :atomic_upgrade?])
|> Keyword.merge(Keyword.get(opts, :bulk_options, []))
|> Enum.concat(changeset_opts)
|> Keyword.put(:resource, unquote(resource))
|> then(fn bulk_opts ->
if method == :id || unquote(interface.get?) do
bulk_opts
|> Keyword.put(:return_records?, true)
|> Keyword.put(:return_errors?, true)
|> Keyword.put_new(:authorize_with, :error)
|> Keyword.put(:notify?, true)
else
bulk_opts
end
end)
|> Keyword.put_new(:strategy, [:atomic, :stream, :atomic_batches])
bulk_opts =
if method in [:stream, :query] do
Keyword.put(bulk_opts, :filter, filters)
else
bulk_opts
end
case Ash.CodeInterface.bulk_query(unquote(resource), method, id) do
{:ok, query} ->
query
|> Ash.bulk_update(unquote(action.name), params, bulk_opts)
|> case do
%Ash.BulkResult{} = result
when method in [:stream, :query] and not unquote(interface.get?) ->
result
%Ash.BulkResult{status: :success, records: [record]} = result ->
if opts[:return_notifications?] do
{:ok, record, result.notifications}
else
{:ok, record}
end
%Ash.BulkResult{status: :success, records: []} = result ->
{:error,
Ash.Error.to_error_class(
Ash.Error.Query.NotFound.exception(
resource: unquote(resource),
primary_key: id
)
)}
%Ash.BulkResult{status: :error, errors: errors} ->
{:error, Ash.Error.to_error_class(errors)}
end
{:error, error} ->
{:error, Ash.Error.to_error_class(error)}
end
changeset ->
Ash.update(changeset, Keyword.delete(opts, :bulk_options))
end
end
act! =
quote do
case changeset do
{:atomic, method, id} ->
{filters, params} = Map.split(params, unquote(filter_keys))
bulk_opts =
opts
|> Keyword.drop([:bulk_options, :atomic_upgrade?])
|> Keyword.merge(Keyword.get(opts, :bulk_options, []))
|> Enum.concat(changeset_opts)
|> Keyword.put(:resource, unquote(resource))
|> then(fn bulk_opts ->
if method == :id || unquote(interface.get?) do
bulk_opts
|> Keyword.put(:return_records?, true)
|> Keyword.put(:return_errors?, true)
|> Keyword.put_new(:authorize_with, :error)
|> Keyword.put(:notify?, true)
else
bulk_opts
end
end)
|> Keyword.put_new(:strategy, [:atomic, :stream, :atomic_batches])
bulk_opts =
if method in [:stream] do
Keyword.put(bulk_opts, :filter, filters)
else
bulk_opts
end
case Ash.CodeInterface.bulk_query(unquote(resource), method, id) do
{:ok, query} ->
query
|> Ash.bulk_update!(unquote(action.name), params, bulk_opts)
|> case do
%Ash.BulkResult{} = result
when method in [:stream, :query] and not unquote(interface.get?) ->
result
%Ash.BulkResult{status: :success, records: [record]} = result ->
if opts[:return_notifications?] do
{record, result.notifications}
else
record
end
%Ash.BulkResult{status: :success, records: []} = result ->
raise Ash.Error.to_error_class(
Ash.Error.Query.NotFound.exception(
resource: unquote(resource),
primary_key: id
)
)
end
{:error, error} ->
raise Ash.Error.to_error_class(error)
end
changeset ->
Ash.update!(changeset, Keyword.delete(opts, :bulk_options))
end
end
{subject, subject_args, resolve_subject, act, act!}
:destroy ->
subject = quote do: changeset
subject_args =
if interface.require_reference? do
quote do: [record]
else
[]
end
resolve_subject =
if interface.require_reference? do
quote do
{changeset_opts, opts} =
Keyword.split(opts, [
:actor,
:tenant,
:authorize?,
:tracer,
:context,
:skip_unknown_inputs
])
changeset_opts = Keyword.put(changeset_opts, :domain, unquote(domain))
changeset =
record
|> case do
%Ash.Changeset{resource: unquote(resource)} ->
{filters, params} = Map.split(params, unquote(filter_keys))
record
|> Ash.Changeset.filter(filters)
|> Ash.Changeset.for_destroy(
unquote(action.name),
params,
changeset_opts
)
%Ash.Changeset{resource: other_resource} ->
raise ArgumentError,
"Changeset #{inspect(record)} does not match expected resource #{inspect(unquote(resource))}."
%struct{} = record when struct == unquote(resource) ->
{filters, params} = Map.split(params, unquote(filter_keys))
record
|> Ash.Changeset.new()
|> Ash.Changeset.filter(filters)
|> Ash.Changeset.for_destroy(
unquote(action.name),
params,
changeset_opts
)
%Ash.Query{} = query ->
{:atomic, :query, query}
%other_resource{} when other_resource != unquote(resource) ->
raise ArgumentError,
"Record #{inspect(record)} does not match expected resource #{inspect(unquote(resource))}."
[{_key, _val} | _] = id ->
{:atomic, :id, id}
list when is_list(list) ->
{:atomic, :stream, list}
other ->
{:atomic, :id, other}
end
end
else
quote do
filters = Map.take(params, unquote(filter_keys))
{changeset_opts, opts} =
Keyword.split(opts, [
:actor,
:tenant,
:authorize?,
:tracer,
:context,
:skip_unknown_inputs
])
changeset_opts = Keyword.put(changeset_opts, :domain, unquote(domain))
changeset =
{:atomic, :query, Ash.Query.do_filter(unquote(resource), filters)}
end
end
act =
quote do
case changeset do
{:atomic, method, id} ->
{filters, params} = Map.split(params, unquote(filter_keys))
bulk_opts =
opts
|> Keyword.drop([:bulk_options, :return_destroyed?])
|> Keyword.merge(Keyword.get(opts, :bulk_options, []))
|> Enum.concat(changeset_opts)
|> Keyword.put(:resource, unquote(resource))
|> then(fn bulk_opts ->
if method == :id || unquote(interface.get?) do
bulk_opts
|> Keyword.put(:return_records?, opts[:return_destroyed?])
|> Keyword.put(:return_errors?, true)
|> Keyword.put_new(:authorize_with, :error)
|> Keyword.put(:notify?, true)
else
Keyword.put(bulk_opts, :return_records?, opts[:return_destroyed?])
end
end)
|> Keyword.put_new(:strategy, [:atomic, :stream, :atomic_batches])
bulk_opts =
if method in [:stream, :query] do
Keyword.put(bulk_opts, :filter, filters)
else
bulk_opts
end
case Ash.CodeInterface.bulk_query(unquote(resource), method, id) do
{:ok, query} ->
query
|> Ash.bulk_destroy(unquote(action.name), params, bulk_opts)
|> case do
%Ash.BulkResult{} = result
when method in [:stream, :query] and not unquote(interface.get?) ->
result
%Ash.BulkResult{status: :success, records: [record]} = result ->
if opts[:return_destroyed?] do
if opts[:return_notifications?] do
{:ok, record, result.notifications}
else
{:ok, record}
end
else
if opts[:return_notifications?] do
{:ok, result.notifications}
else
:ok
end
end
%Ash.BulkResult{status: :success, records: empty} = result
when empty in [[], nil] ->
if opts[:return_destroyed?] do
{:error,
Ash.Error.to_error_class(
Ash.Error.Query.NotFound.exception(
resource: unquote(resource),
primary_key: id
)
)}
else
if opts[:return_notifications?] do
{:ok, result.notifications}
else
:ok
end
end
%Ash.BulkResult{status: :error, errors: errors} ->
{:error, Ash.Error.to_error_class(errors)}
end
{:error, error} ->
{:error, Ash.Error.to_error_class(error)}
end
changeset ->
Ash.destroy(changeset, Keyword.delete(opts, :bulk_options))
end
end
act! =
quote do
case changeset do
{:atomic, method, id} ->
{filters, params} = Map.split(params, unquote(filter_keys))
bulk_opts =
opts
|> Keyword.drop([:bulk_options, :return_destroyed?])
|> Keyword.merge(Keyword.get(opts, :bulk_options, []))
|> Enum.concat(changeset_opts)
|> Keyword.put(:resource, unquote(resource))
|> then(fn bulk_opts ->
if method == :id || unquote(interface.get?) do
bulk_opts
|> Keyword.put(:return_records?, opts[:return_destroyed?])
|> Keyword.put(:return_errors?, true)
|> Keyword.put_new(:authorize_with, :error)
|> Keyword.put(:notify?, true)
else
Keyword.put(bulk_opts, :return_records?, opts[:return_destroyed?])
end
end)
|> Keyword.put_new(:strategy, [:atomic, :stream, :atomic_batches])
bulk_opts =
if method in [:stream, :query] do
Keyword.put(bulk_opts, :filter, filters)
else
bulk_opts
end
case Ash.CodeInterface.bulk_query(unquote(resource), method, id) do
{:ok, query} ->
query
|> Ash.bulk_destroy!(unquote(action.name), params, bulk_opts)
|> case do
%Ash.BulkResult{} = result
when method in [:stream, :query] and not unquote(interface.get?) ->
result
%Ash.BulkResult{status: :success, records: [record]} = result ->
if opts[:return_destroyed?] do
if opts[:return_notifications?] do
{record, result.notifications}
else
record
end
else
if opts[:return_notifications?] do
result.notifications
else
:ok
end
end
%Ash.BulkResult{status: :success, records: empty} = result
when empty in [[], nil] ->
if opts[:return_destroyed?] do
raise Ash.Error.to_error_class(
Ash.Error.Query.NotFound.exception(
resource: unquote(resource),
primary_key: id
)
)
else
if opts[:return_notifications?] do
{:ok, result.notifications}
else
:ok
end
end
end
{:error, error} ->
raise Ash.Error.to_error_class(error)
end
changeset ->
Ash.destroy!(changeset, Keyword.delete(opts, :bulk_options))
end
end
{subject, subject_args, resolve_subject, act, act!}
end
subject_name = elem(subject, 0)
resolve_subject =
quote do
unquote(resolve_subject)
end
common_args =
quote do: [
unquote_splicing(subject_args),
unquote_splicing(arg_vars_function),
params_or_opts \\ %{},
opts \\ []
]
first_opts_location = Enum.count(subject_args) + Enum.count(arg_vars_function)
@doc """
#{action.description || "Calls the #{action.name} action on #{inspect(resource)}."}
#{Ash.CodeInterface.describe_action(resource, action, interface.args)}
## Options
#{interface_options.docs()}
"""
|> Ash.CodeInterface.trim_double_newlines()
@dialyzer {:nowarn_function, {interface.name, length(common_args)}}
@doc spark_opts: [
{first_opts_location, interface_options.schema()},
{first_opts_location + 1, interface_options.schema()}
]
def unquote(interface.name)(unquote_splicing(common_args)) do
unquote(resolve_opts_params)
unquote(resolve_subject)
unquote(act)
end
@doc """
#{action.description || "Calls the #{action.name} action on #{inspect(resource)}."}
Raises any errors instead of returning them
#{Ash.CodeInterface.describe_action(resource, action, interface.args)}
## Options
#{interface_options.docs()}
"""
|> Ash.CodeInterface.trim_double_newlines()
# sobelow_skip ["DOS.BinToAtom"]
@dialyzer {:nowarn_function, {:"#{interface.name}!", length(common_args)}}
@doc spark_opts: [
{first_opts_location, interface_options.schema()},
{first_opts_location + 1, interface_options.schema()}
]
def unquote(:"#{interface.name}!")(unquote_splicing(common_args)) do
unquote(resolve_bang_opts_params)
unquote(resolve_subject)
unquote(act!)
end
# sobelow_skip ["DOS.BinToAtom"]
if subject_name in [:changeset, :query, :input] do
subject_opts =
Keyword.take(interface_options.schema(), [
:actor,
:tenant,
:authorize?,
:tracer,
:changeset,
:query,
:input
])
@dialyzer {:nowarn_function,
{:"#{subject_name}_to_#{interface.name}", length(common_args)}}
@doc spark_opts: [
{first_opts_location, interface_options.schema()},
{first_opts_location + 1, interface_options.schema()}
]
@doc """
Returns the #{subject_name} corresponding to the action.
## Options
#{Spark.Options.docs(subject_opts)}
"""
|> Ash.CodeInterface.trim_double_newlines()
@doc spark_opts: [
{first_opts_location, subject_opts},
{first_opts_location + 1, subject_opts}
]
def unquote(:"#{subject_name}_to_#{interface.name}")(unquote_splicing(common_args)) do
unquote(resolve_opts_params)
unquote(resolve_subject)
unquote(subject)
end
end
# sobelow_skip ["DOS.BinToAtom"]
@doc """
Runs authorization checks for `#{inspect(resource)}.#{action.name}`
See `Ash.can/3` for more information
## Options
#{Ash.Resource.Interface.CanOpts.docs()}
"""
|> Ash.CodeInterface.trim_double_newlines()
@dialyzer {:nowarn_function, {:"can_#{interface.name}", length(common_args) + 1}}
@doc spark_opts: [
{first_opts_location + 1, Ash.Resource.Interface.CanOpts.schema()},
{first_opts_location + 2, Ash.Resource.Interface.CanOpts.schema()}
]
def unquote(:"can_#{interface.name}")(actor, unquote_splicing(common_args)) do
{params, opts} =
if opts == [] && Keyword.keyword?(params_or_opts),
do:
{%{},
Ash.Resource.Interface.CanOpts.validate!(params_or_opts)
|> unquote(interface_options).to_options()},
else:
{params_or_opts,
Ash.Resource.Interface.CanOpts.validate!(opts)
|> unquote(interface_options).to_options()}
opts = Keyword.put(opts, :actor, actor)
unquote(resolve_subject)
case unquote(subject) do
%struct{} when struct in [Ash.Changeset, Ash.Query, Ash.ActionInput] ->
Ash.can(unquote(subject), actor, opts)
{:atomic, _, input} ->
raise "Ash.can_#{unquote(interface.name)} does not support #{inspect(input)} as input."
{:bulk, input} ->
raise "Ash.can_#{unquote(interface.name)} does not support #{inspect(input)} as input."
other ->
raise "Ash.can_#{unquote(interface.name)} does not support #{inspect(other)} as input."
end
end
# sobelow_skip ["DOS.BinToAtom"]
@dialyzer {:nowarn_function, {:"can_#{interface.name}?", length(common_args) + 1}}
@doc spark_opts: [
{first_opts_location + 1, Ash.Resource.Interface.CanQuestionMarkOpts.schema()},
{first_opts_location + 2, Ash.Resource.Interface.CanQuestionMarkOpts.schema()}
]
@doc """
Runs authorization checks for `#{inspect(resource)}.#{action.name}`, returning a boolean.
See `Ash.can?/3` for more information
## Options
#{Ash.Resource.Interface.CanQuestionMarkOpts.docs()}
"""
|> Ash.CodeInterface.trim_double_newlines()
def unquote(:"can_#{interface.name}?")(actor, unquote_splicing(common_args)) do
{params, opts} =
if opts == [] && Keyword.keyword?(params_or_opts),
do:
{%{},
Ash.Resource.Interface.CanQuestionMarkOpts.validate!(params_or_opts)
|> unquote(interface_options).to_options()},
else:
{params_or_opts,
Ash.Resource.Interface.CanQuestionMarkOpts.validate!(opts)
|> unquote(interface_options).to_options()}
opts = Keyword.put(opts, :actor, actor)
unquote(resolve_subject)
case unquote(subject) do
%struct{} when struct in [Ash.Changeset, Ash.Query, Ash.ActionInput] ->
Ash.can?(unquote(subject), actor, opts)
{:atomic, _, input} ->
raise "Ash.can_#{unquote(interface.name)}? does not support #{inspect(input)} as input."
{:bulk, input} ->
raise "Ash.can_#{unquote(interface.name)}? does not support #{inspect(input)} as input."
other ->
raise "Ash.can_#{unquote(interface.name)}? does not support #{inspect(other)} as input."
end
end
end
end
end
def describe_action(resource, action, args) do
resource
|> Ash.Resource.Info.action_inputs(action.name)
|> Enum.filter(&is_atom/1)
|> Enum.uniq()
|> case do
[] ->
""
inputs ->
{arguments, inputs} = Enum.split_with(inputs, &(&1 in (args || [])))
arguments =
Enum.map(arguments, &describe_input(resource, action, &1))
inputs =
Enum.map(inputs, &describe_input(resource, action, &1))
case {arguments, inputs} do
{[], []} ->
""
{arguments, []} ->
"""
# Arguments
#{Enum.join(arguments, "\n")}
"""
{[], inputs} ->
"""
# Inputs
#{Enum.join(inputs, "\n")}
"""
{arguments, inputs} ->
"""
# Arguments
#{Enum.join(arguments, "\n")}
# Inputs
#{Enum.join(inputs, "\n")}
"""
end
end
end
def describe_calculation(resource, calculation, args) do
calculation.arguments
|> Enum.map(& &1.name)
|> case do
[] ->
""
inputs ->
{arguments, inputs} = Enum.split_with(inputs, &(&1 in args))
arguments = Enum.sort_by(arguments, fn arg -> Enum.find_index(args, &(&1 == arg)) end)
arguments =
Enum.map(arguments, &describe_input(resource, calculation, &1))
inputs =
Enum.map(inputs, &describe_input(resource, calculation, &1))
case {arguments, inputs} do
{[], []} ->
""
{arguments, []} ->
"""
# Arguments
#{Enum.join(arguments, "\n")}
"""
{[], inputs} ->
"""
# Inputs
#{Enum.join(inputs, "\n")}
"""
{arguments, inputs} ->
"""
# Arguments
#{Enum.join(arguments, "\n")}
# Inputs
#{Enum.join(inputs, "\n")}
"""
end
end
end
defp describe_input(resource, %{arguments: arguments}, name) do
case Enum.find(arguments, &(&1.name == name)) do
nil ->
case Ash.Resource.Info.field(resource, name) do
nil ->
"* #{name}"
field ->
describe(field)
end
argument ->
describe(argument)
end
end
defp describe(%{name: name, description: description}) when not is_nil(description) do
"* #{name} - #{description}"
end
defp describe(%{name: name}) do
"* #{name}"
end
def trim_double_newlines(str) do
str
|> String.replace(~r/\n{2,}/, "\n")
|> String.trim_trailing()
end
@doc false
def bulk_query(resource, method, id) do
case method do
:query ->
{:ok, id}
:stream ->
{:ok, id}
:id ->
case Ash.Filter.get_filter(resource, id) do
{:ok, filter} ->
{:ok, Ash.Query.do_filter(resource, filter)}
{:error, error} ->
{:error, error}
end
end
end
end
