View Source DSL: Ash.Reactor

reactor.action.inputs

inputs template

Specify the inputs for an action

Examples

inputs %{
  author: result(:get_user),
  title: input(:title),
  body: input(:body)
}

inputs(author: result(:get_user))

Arguments

Name	Type	Default	Docs
`template`	`%{optional(atom) => Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value)`

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which will transform the inputs before executing the action.

Introspection

reactor.action.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the tenant.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the tenant before it is passed to the action.

Introspection

reactor.action.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.Action

reactor.ash_step

ash_step name, impl \\ nil

Specifies a Ash.Reactor step.

This is basically a wrapper around Reactor.step, in order to handle any returned notifications from the run step/function.

See the Reactor.Step behaviour for more information.

Nested DSLs

argument
wait_for

Examples

ash_step :create_post, MyApp.CreatePostStep do
  argument :title, input(:title)
end

ash_step :create_post do
  argument :title, input(:title)

  run fn %{title: title}, _ ->
    MyApp.Post.create(title, return_notifications?: true)
  end
end

Arguments

Name	Type	Default	Docs
`name`	`atom`		A unique name for the step. Used when choosing the return value of the Reactor and for arguments into other steps.
`impl`	`module \| nil`		A module that implements the `Reactor.Step` behaviour that provides the implementation.

Options

Name	Type	Default	Docs
`run`	`(any -> any) \| mfa \| (any, any -> any) \| mfa`		Provide an anonymous function which implements the `run/3` callback. Cannot be provided at the same time as the `impl` argument.
`undo`	`(any -> any) \| mfa \| (any, any -> any) \| mfa \| (any, any, any -> any) \| mfa`		Provide an anonymous function which implements the `undo/4` callback. Cannot be provided at the same time as the `impl` argument.
`compensate`	`(any -> any) \| mfa \| (any, any -> any) \| mfa \| (any, any, any -> any) \| mfa`		Provide an anonymous function which implements the `undo/4` callback. Cannot be provided at the same time as the `impl` argument.
`max_retries`	`:infinity \| non_neg_integer`	`:infinity`	The maximum number of times that the step can be retried before failing. Only used when the result of the `compensate/4` callback is `:retry`.
`async?`	`boolean`	`true`	When set to true the step will be executed asynchronously via Reactor's `TaskSupervisor`.
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the entire argument map before it is passed to the step.

reactor.ash_step.argument

argument name, source \\ nil

Specifies an argument to a Reactor step.

Each argument is a value which is either the result of another step, or an input value.

Individual arguments can be transformed with an arbitrary function before being passed to any steps.

Examples

argument :name, input(:name)

argument :year, input(:date, [:year])

argument :user, result(:create_user)

argument :user_id, result(:create_user) do
  transform & &1.id
end

argument :user_id, result(:create_user, [:id])

argument :three, value(3)

Arguments

Name	Type	Default	Docs
`name`	`atom`		The name of the argument which will be used as the key in the `arguments` map passed to the implementation.
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the argument. See `Reactor.Dsl.Argument` for more information.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the argument before it is passed to the step.

Introspection

Target: Reactor.Dsl.Argument

reactor.ash_step.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.AshStep

reactor.bulk_create

bulk_create name, resource, action \\ nil

Declares a step which will call a create action on a resource with a collection of inputs.

Check the docs!

Make sure to thoroughly read and understand the documentation in Ash.bulk_create/4 before using. Read each option and note the default values. By default, bulk creates don't return records or errors, and don't emit notifications.

Caveats/differences from Ash.bulk_create/4:

max_concurrency specifies the number of tasks that Ash will start to process batches, and has no effect on Reactor concurrency targets. It's could be possible to create a very large number of processes if a number of steps are running bulk actions with a high degree of concurrency.
Setting notify? to true will cause both notify? and return_notifications? to be set to true in the underlying call to Ash.bulk_create/4. Notifications will then be managed by the Ash.Reactor.Notifications Reactor middleware.
If you specify an undo action it must be a generic action which takes the bulk result as it's only argument.

Undo behaviour
This step has three different modes of undo.
never - The result of the action is never undone. This is the default.
always - The undo_action will always be called.
outside_transaction - The undo_action will not be called when running inside a transaction block, but will be otherwise.

Nested DSLs

actor
tenant
wait_for

Examples

bulk_create :create_posts, MyApp.Post, :create do
  initial input(:titles)
  actor result(:get_user)
  tenant result(:get_organisation, [:id])
end

Arguments

Name	Type	Docs
`name`	`atom`	A unique name for the step.
`resource`	`module`	The resource to call the action on.
`action`	`atom`	The name of the action to call on the resource.

Options

Name	Type	Default	Docs
`initial`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		A collection of inputs to pass to the create action. Must implement the `Enumerable` protocol.
`assume_casted?`	`boolean`	`false`	Whether or not to cast attributes and arguments as input. This is an optimization for cases where the input is already casted and/or not in need of casting
`authorize_changeset_with`	`:filter \| :error`	`:filter`	If set to `:error`, instead of filtering unauthorized changes, unauthorized changes will raise an appropriate forbidden error
`authorize_query_with`	`:filter \| :error`	`:filter`	If set to `:error`, instead of filtering unauthorized query results, unauthorized query results will raise an appropriate forbidden error
`batch_size`	`nil \| pos_integer`		The number of records to include in each batch. Defaults to the `default_limit` or `max_page_size` of the action, or 100.
`load`	`atom \| list(atom)`	`[]`	A load statement to apply to records. Ignored if `return_records?` is not true.
`max_concurrency`	`non_neg_integer`	`0`	If set to a value greater than 0, up to that many tasks will be started to run batches asynchronously.
`notification_metadata`	`map \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`	`%{}`	Metadata to be merged into the metadata field for all notifications sent from this operation.
`notify?`	`boolean`	`false`	Whether or not to generate any notifications. This may be intensive for large bulk actions.
`read_action`	`atom`		The action to use when building the read query.
`return_errors?`	`boolean`	`false`	Whether or not to return all of the errors that occur. Defaults to false to account for large inserts.
`return_records?`	`boolean`	`false`	Whether or not to return all of the records that were inserted. Defaults to false to account for large inserts.
`return_stream?`	`boolean`	`false`	If set to `true`, instead of an `Ash.BulkResult`, a mixed stream is returned.
`rollback_on_error?`	`boolean`	`true`	Whether or not to rollback the transaction on error, if the resource is in a transaction.
`select`	`atom \| list(atom)`		A select statement to apply to records. Ignored if `return_records?` is not `true`.
`skip_unknown_inputs`	`atom \| list(atom)`		A list of inputs that, if provided, will be ignored if they are not recognized by the action.
`sorted?`	`boolean`	`false`	Whether or not to sort results by their input position, in cases where `return_records?` is set to `true`.
`stop_on_error?`	`boolean`	`false`	If `true`, the first encountered error will stop the action and be returned. Otherwise, errors will be skipped.
`success_state`	`:success \| :partial_success`	`:success`	Bulk results can be entirely or partially successful. Chooses the `Ash.BulkResult` state to consider the step a success.
`timeout`	`timeout`		If none is provided, the timeout configured on the domain is used (which defaults to `30_000`).
`transaction`	`:all \| :batch \| false`	`:batch`	Whether or not to wrap the entire execution in a transaction, each batch, or not at all.
`upsert_fields`	`atom \| list(atom)`		The fields to upsert. If not set, the action's `upsert_fields` is used.
`upsert_identity`	`atom`		The identity to use for the upsert
`upsert?`	`boolean`	`false`	Whether or not this action should be executed as an upsert.
`domain`	`module`		The Domain to use when calling the action. Defaults to the Domain set on the resource or in the `ash` section.
`async?`	`boolean`	`true`	When set to true the step will be executed asynchronously via Reactor's `TaskSupervisor`.
`authorize?`	`boolean \| nil`		Explicitly enable or disable authorization for the action.
`description`	`String.t`		A description for the step
`undo_action`	`atom`		The name of the action to call on the resource when the step is to be undone.
`undo`	`:always \| :never \| :outside_transaction`	`:never`	How to handle undoing this action

reactor.bulk_create.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the actor.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the actor before it is passed to the action.

Introspection

reactor.bulk_create.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the tenant.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the tenant before it is passed to the action.

Introspection

reactor.bulk_create.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.BulkCreate

reactor.bulk_update

bulk_update name, resource, action \\ nil

Declares a step which will call an update action on a resource with a collection of inputs.

Check the docs!

Make sure to thoroughly read and understand the documentation in Ash.bulk_update/4 before using. Read each option and note the default values. By default, bulk updates don't return records or errors, and don't emit notifications.

Caveats/differences from Ash.bulk_update/4:

max_concurrency specifies the number of tasks that Ash will start to process batches, and has no effect on Reactor concurrency targets. It's could be possible to create a very large number of processes if a number of steps are running bulk actions with a high degree of concurrency.
Setting notify? to true will cause both notify? and return_notifications? to be set to true in the underlying call to Ash.bulk_create/4. Notifications will then be managed by the Ash.Reactor.Notifications Reactor middleware.
If you specify an undo action it must be a generic action which takes the bulk result as it's only argument.

Undo behaviour
This step has three different modes of undo.
never - The result of the action is never undone. This is the default.
always - The undo_action will always be called.
outside_transaction - The undo_action will not be called when running inside a transaction block, but will be otherwise.

Nested DSLs

actor
inputs
tenant
wait_for

Examples

bulk_update :publish_posts, MyApp.Post, :publish do
  initial input(:posts),
  actor result(:get_user)
end

Arguments

Name	Type	Docs
`name`	`atom`	A unique name for the step.
`resource`	`module`	The resource to call the action on.
`action`	`atom`	The name of the action to call on the resource.

Options

Name	Type	Default	Docs
`initial`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		A collection of inputs to pass to the create action. Must implement the `Enumerable` protocol.
`allow_stream_with`	`:keyset \| :offset \| :full_read`	`:keyset`	The 'worst' strategy allowed to be used to fetch records if the :stream strategy is chosen. See the `Ash.stream!/2` docs for more.
`assume_casted?`	`boolean`	`false`	Whether or not to cast attributes and arguments as input. This is an optimization for cases where the input is already casted and/or not in need of casting
`atomic_update`	`map`		A map of atomic updates to apply. See `Ash.Changeset.atomic_update/3` for more.
`authorize_changeset_with`	`:filter \| :error`	`:filter`	If set to `:error`, instead of filtering unauthorized changes, unauthorized changes will raise an appropriate forbidden error
`authorize_query_with`	`:filter \| :error`	`:filter`	If set to `:error`, instead of filtering unauthorized query results, unauthorized query results will raise an appropriate forbidden error
`authorize_query?`	`boolean`	`true`	If a query is given, determines whether or not authorization is run on that query.
`batch_size`	`nil \| pos_integer`		The number of records to include in each batch. Defaults to the `default_limit` or `max_page_size` of the action, or 100.
`filter`	`map \| keyword`		A filter to apply to records. This is also applied to a stream of inputs.
`load`	`atom \| list(atom)`	`[]`	A load statement to apply to records. Ignored if `return_records?` is not true.
`lock`	`any`		A lock statement to add onto the query.
`max_concurrency`	`non_neg_integer`	`0`	If set to a value greater than 0, up to that many tasks will be started to run batches asynchronously.
`notification_metadata`	`map \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`	`%{}`	Metadata to be merged into the metadata field for all notifications sent from this operation.
`notify?`	`boolean`	`false`	Whether or not to generate any notifications. This may be intensive for large bulk actions.
`page`	`keyword`	`[]`	Pagination options, see the pagination docs for more.
`read_action`	`atom`		The action to use when building the read query.
`return_errors?`	`boolean`	`false`	Whether or not to return all of the errors that occur. Defaults to false to account for large inserts.
`return_records?`	`boolean`	`false`	Whether or not to return all of the records that were inserted. Defaults to false to account for large inserts.
`return_stream?`	`boolean`	`false`	If set to `true`, instead of an `Ash.BulkResult`, a mixed stream is returned.
`reuse_values?`	`boolean`	`false`	Whether calculations are allowed to reuse values that have already been loaded, or must refetch them from the data layer.
`rollback_on_error?`	`boolean`	`true`	Whether or not to rollback the transaction on error, if the resource is in a transaction.
`select`	`atom \| list(atom)`		A select statement to apply to records. Ignored if `return_records?` is not `true`.
`skip_unknown_inputs`	`atom \| list(atom)`		A list of inputs that, if provided, will be ignored if they are not recognized by the action.
`sorted?`	`boolean`	`false`	Whether or not to sort results by their input position, in cases where `return_records?` is set to `true`.
`stop_on_error?`	`boolean`	`false`	If `true`, the first encountered error will stop the action and be returned. Otherwise, errors will be skipped.
`strategy`	`list(:atomic \| :atomic_batches \| :stream)`	`[:atomic]`	The strategy or strategies to enable. `:stream` is used in all cases if the data layer does not support atomics.
`stream_batch_size`	`pos_integer`		Batch size to use if provided a query and the query must be streamed.
`stream_with`	`:keyset \| :offset \| :full_read`		The specific strategy to use to fetch records. See `Ash.stream!/2` docs for more.
`success_state`	`:success \| :partial_success`	`:success`	Bulk results can be entirely or partially successful. Chooses the `Ash.BulkResult` state to consider the step a success.
`timeout`	`timeout`		If none is provided, the timeout configured on the domain is used (which defaults to `30_000`).
`transaction`	`:all \| :batch \| false`	`:batch`	Whether or not to wrap the entire execution in a transaction, each batch, or not at all.
`domain`	`module`		The Domain to use when calling the action. Defaults to the Domain set on the resource or in the `ash` section.
`async?`	`boolean`	`true`	When set to true the step will be executed asynchronously via Reactor's `TaskSupervisor`.
`authorize?`	`boolean \| nil`		Explicitly enable or disable authorization for the action.
`description`	`String.t`		A description for the step
`undo_action`	`atom`		The name of the action to call on the resource when the step is to be undone.
`undo`	`:always \| :never \| :outside_transaction`	`:never`	How to handle undoing this action

reactor.bulk_update.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the actor.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the actor before it is passed to the action.

Introspection

reactor.bulk_update.inputs

inputs template

Specify the inputs for an action

Examples

inputs %{
  author: result(:get_user),
  title: input(:title),
  body: input(:body)
}

inputs(author: result(:get_user))

Arguments

Name	Type	Default	Docs
`template`	`%{optional(atom) => Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value)`

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which will transform the inputs before executing the action.

Introspection

reactor.bulk_update.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the tenant.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the tenant before it is passed to the action.

Introspection

reactor.bulk_update.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.BulkUpdate

reactor.change

change name, change

Declares a step that will modify a changeset.

Nested DSLs

argument
wait_for

Arguments

Name	Type	Default	Docs
`name`	`atom`		A unique name for this step.
`change`	`(any, any -> any) \| module`		The module and options for a change. Also accepts a function that takes the changeset and the context. See `Ash.Resource.Change.Builtins` for builtin changes.

Options

Name	Type	Default	Docs
`initial`	`module \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		The initial value to work from, either a resource or a changeset
`description`	`String.t \| nil`		An optional description for the change
`only_when_valid?`	`boolean`	`false`	If the change should only be run on valid changes. By default, all changes are run unless stated otherwise here.
`where`	`(any, any -> any) \| module \| list((any, any -> any) \| module)`	`[]`	Validations that should pass in order for this change to apply. These validations failing will result in this change being ignored.
`fail_if_invalid?`	`boolean`	`false`	Fail if the result of the change is an invalid changeset

reactor.change.argument

argument name, source \\ nil

Specifies an argument to a Reactor step.

Each argument is a value which is either the result of another step, or an input value.

Individual arguments can be transformed with an arbitrary function before being passed to any steps.

Examples

argument :name, input(:name)

argument :year, input(:date, [:year])

argument :user, result(:create_user)

argument :user_id, result(:create_user) do
  transform & &1.id
end

argument :user_id, result(:create_user, [:id])

argument :three, value(3)

Arguments

Name	Type	Default	Docs
`name`	`atom`		The name of the argument which will be used as the key in the `arguments` map passed to the implementation.
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the argument. See `Reactor.Dsl.Argument` for more information.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the argument before it is passed to the step.

Introspection

Target: Reactor.Dsl.Argument

reactor.change.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.Change

reactor.create

create name, resource, action \\ nil

Declares a step that will call a create action on a resource.

Undo behaviour
This step has three different modes of undo.
never - The result of the action is never undone. This is the default.
always - The undo_action will always be called.
outside_transaction - The undo_action will not be called when running inside a transaction block, but will be otherwise.

Nested DSLs

actor
inputs
tenant
wait_for

Examples

create :create_post, MyApp.Post, :create do
  inputs %{
    title: input(:post_title),
    author_id: result(:get_user, [:id])
  }
  actor result(:get_user)
  tenant result(:get_organisation, [:id])
end

Arguments

Name	Type	Docs
`name`	`atom`	A unique name for the step.
`resource`	`module`	The resource to call the action on.
`action`	`atom`	The name of the action to call on the resource.

Options

Name	Type	Default	Docs
`initial`	`nil \| module \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		The initial value passed into the action.
`upsert_identity`	`atom`		The identity to use for the upsert
`upsert?`	`boolean`	`false`	Whether or not this action should be executed as an upsert.
`domain`	`module`		The Domain to use when calling the action. Defaults to the Domain set on the resource or in the `ash` section.
`async?`	`boolean`	`true`	When set to true the step will be executed asynchronously via Reactor's `TaskSupervisor`.
`authorize?`	`boolean \| nil`		Explicitly enable or disable authorization for the action.
`description`	`String.t`		A description for the step
`undo_action`	`atom`		The name of the action to call on the resource when the step is to be undone.
`undo`	`:always \| :never \| :outside_transaction`	`:never`	How to handle undoing this action

reactor.create.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the actor.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the actor before it is passed to the action.

Introspection

reactor.create.inputs

inputs template

Specify the inputs for an action

Examples

inputs %{
  author: result(:get_user),
  title: input(:title),
  body: input(:body)
}

inputs(author: result(:get_user))

Arguments

Name	Type	Default	Docs
`template`	`%{optional(atom) => Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value)`

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which will transform the inputs before executing the action.

Introspection

reactor.create.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the tenant.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the tenant before it is passed to the action.

Introspection

reactor.create.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.Create

reactor.destroy

destroy name, resource, action \\ nil

Declares a step that will call a destroy action on a resource.

Undo behaviour
This step has three different modes of undo.
never - The result of the action is never undone. This is the default.
always - The undo_action will always be called.
outside_transaction - The undo_action will not be called when running inside a transaction block, but will be otherwise.

Nested DSLs

actor
inputs
tenant
wait_for

Examples

destroy :delete_post, MyApp.Post, :destroy do
  initial input(:post)
  actor result(:get_user)
  tenant result(:get_organisation, [:id])
end

Arguments

Name	Type	Docs
`name`	`atom`	A unique name for the step.
`resource`	`module`	The resource to call the action on.
`action`	`atom`	The name of the action to call on the resource.

Options

Name	Type	Default	Docs
`initial`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		The record to update.
`return_destroyed?`	`boolean`	`false`	Whether or not the step should return the destroyed record upon completion.
`domain`	`module`		The Domain to use when calling the action. Defaults to the Domain set on the resource or in the `ash` section.
`async?`	`boolean`	`true`	When set to true the step will be executed asynchronously via Reactor's `TaskSupervisor`.
`authorize?`	`boolean \| nil`		Explicitly enable or disable authorization for the action.
`description`	`String.t`		A description for the step
`undo_action`	`atom`		The name of the action to call on the resource when the step is to be undone.
`undo`	`:always \| :never \| :outside_transaction`	`:never`	How to handle undoing this action

reactor.destroy.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the actor.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the actor before it is passed to the action.

Introspection

reactor.destroy.inputs

inputs template

Specify the inputs for an action

Examples

inputs %{
  author: result(:get_user),
  title: input(:title),
  body: input(:body)
}

inputs(author: result(:get_user))

Arguments

Name	Type	Default	Docs
`template`	`%{optional(atom) => Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value)`

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which will transform the inputs before executing the action.

Introspection

reactor.destroy.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the tenant.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the tenant before it is passed to the action.

Introspection

reactor.destroy.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.Destroy

reactor.read_one

read_one name, resource, action \\ nil

Declares a step that will call a read action on a resource returning a single record.

Nested DSLs

actor
inputs
tenant
wait_for

Examples

read_one :post_by_id, MyApp.Post, :read do
  inputs %{id: input(:post_id)}
end

Arguments

Name	Type	Docs
`name`	`atom`	A unique name for the step.
`resource`	`module`	The resource to call the action on.
`action`	`atom`	The name of the action to call on the resource.

Options

Name	Type	Default	Docs
`fail_on_not_found?`	`boolean`	`false`	When set to true the step will fail if the resource is not found.
`domain`	`module`		The Domain to use when calling the action. Defaults to the Domain set on the resource or in the `ash` section.
`async?`	`boolean`	`true`	When set to true the step will be executed asynchronously via Reactor's `TaskSupervisor`.
`authorize?`	`boolean \| nil`		Explicitly enable or disable authorization for the action.
`description`	`String.t`		A description for the step

reactor.read_one.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the actor.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the actor before it is passed to the action.

Introspection

reactor.read_one.inputs

inputs template

Specify the inputs for an action

Examples

inputs %{
  author: result(:get_user),
  title: input(:title),
  body: input(:body)
}

inputs(author: result(:get_user))

Arguments

Name	Type	Default	Docs
`template`	`%{optional(atom) => Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value)`

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which will transform the inputs before executing the action.

Introspection

reactor.read_one.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the tenant.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the tenant before it is passed to the action.

Introspection

reactor.read_one.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.ReadOne

reactor.read

read name, resource, action \\ nil

Declares a step that will call a read action on a resource.

Nested DSLs

actor
inputs
tenant
wait_for

Examples

read :read_posts, MyApp.Post, :read

read :read_posts_in_range, MyApp.Post, :read_in_range do
  inputs %{min_date: input(:min_date), max_date: input(:max_date)}
end

Arguments

Name	Type	Docs
`name`	`atom`	A unique name for the step.
`resource`	`module`	The resource to call the action on.
`action`	`atom`	The name of the action to call on the resource.

Options

Name	Type	Default	Docs
`domain`	`module`		The Domain to use when calling the action. Defaults to the Domain set on the resource or in the `ash` section.
`async?`	`boolean`	`true`	When set to true the step will be executed asynchronously via Reactor's `TaskSupervisor`.
`authorize?`	`boolean \| nil`		Explicitly enable or disable authorization for the action.
`description`	`String.t`		A description for the step

reactor.read.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the actor.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the actor before it is passed to the action.

Introspection

reactor.read.inputs

inputs template

Specify the inputs for an action

Examples

inputs %{
  author: result(:get_user),
  title: input(:title),
  body: input(:body)
}

inputs(author: result(:get_user))

Arguments

Name	Type	Default	Docs
`template`	`%{optional(atom) => Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value)`

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which will transform the inputs before executing the action.

Introspection

reactor.read.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the tenant.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the tenant before it is passed to the action.

Introspection

reactor.read.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.Read

reactor.transaction

transaction name, resources

Creates a group of steps which will be executed inside a data layer transaction.

Nested DSLs

wait_for

Arguments

Name	Type	Default	Docs
`name`	`atom`		A unique name for the step.
`resources`	`module \| list(module)`		A resource or list of resources to consider in the transaction.

Options

Name	Type	Default	Docs
`return`	`atom`		The name of the step whose result will be returned as the return value of the transaction.
`timeout`	`pos_integer \| :infinity`	`15000`	How long to allow the transaction to run before timing out.

reactor.transaction.wait_for

wait_for names

Wait for the named step to complete before allowing this one to start.

Desugars to argument :_, result(step_to_wait_for)

Examples

wait_for :create_user

Arguments

Name	Type	Default	Docs
`names`	`atom \| list(atom)`		The name of the step to wait for.

Introspection

Introspection

Target: Ash.Reactor.Dsl.Transaction

reactor.update

update name, resource, action \\ nil

Declares a step that will call an update action on a resource.

Undo behaviour
This step has three different modes of undo.
never - The result of the action is never undone. This is the default.
always - The undo_action will always be called.
outside_transaction - The undo_action will not be called when running inside a transaction block, but will be otherwise.

Nested DSLs

actor
inputs
tenant
wait_for

Examples

update :publish_post, MyApp.Post, :update do
  initial input(:post)
  inputs %{
    published: value(true)
  }
  actor result(:get_user)
  tenant result(:get_organisation, [:id])
end

Arguments

Name	Type	Docs
`name`	`atom`	A unique name for the step.
`resource`	`module`	The resource to call the action on.
`action`	`atom`	The name of the action to call on the resource.

Options

Name	Type	Default	Docs
`initial`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		The record to update.
`domain`	`module`		The Domain to use when calling the action. Defaults to the Domain set on the resource or in the `ash` section.
`async?`	`boolean`	`true`	When set to true the step will be executed asynchronously via Reactor's `TaskSupervisor`.
`authorize?`	`boolean \| nil`		Explicitly enable or disable authorization for the action.
`description`	`String.t`		A description for the step
`undo_action`	`atom`		The name of the action to call on the resource when the step is to be undone.
`undo`	`:always \| :never \| :outside_transaction`	`:never`	How to handle undoing this action

reactor.update.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`		What to use as the source of the actor.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the actor before it is passed to the action.

Introspection