View Source DSL: Ash.Reactor

reactor.action.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

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

Introspection

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.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Element \| 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.Element \| 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.Element \| 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

context
actor
load
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.Element \| 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.
`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.Element \| 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 \| String.t \| list(atom \| String.t)`		A list of inputs that, if provided, will be ignored if they are not recognized by the action. Use `:*` to indicate all unknown keys.
`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.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

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

Introspection

reactor.bulk_create.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Element \| 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.load

load source

Allows the addition of an Ash load statement to the action

Arguments

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

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the load 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.Element \| 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
context
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.Element \| 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.
`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.Element \| 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 \| String.t \| list(atom \| String.t)`		A list of inputs that, if provided, will be ignored if they are not recognized by the action. Use `:*` to indicate all unknown keys.
`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.Element \| 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.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the context 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.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Element \| 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.Element \| 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.Element \| 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.Element \| 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
context
inputs
load
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.Element \| 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.Element \| 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.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the context 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.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Element \| 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.load

load source

Allows the addition of an Ash load statement to the action

Arguments

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

Options

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

Introspection

reactor.create.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Element \| 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
context
inputs
load
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.Element \| 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.Element \| 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.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the context 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.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Element \| 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.load

load source

Allows the addition of an Ash load statement to the action

Arguments

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

Options

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

Introspection

reactor.destroy.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Element \| 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.load

load name, records, load

Declares a step that will load additional data on a resource.

Nested DSLs

actor
context
tenant
wait_for

Arguments

Name	Type	Docs
`name`	`atom`	A unique name for the step.
`records`	`Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`	The records upon which to add extra loaded data
`load`	`Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value`	An Ash load statement

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
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the load statement before it is passed to the load.
`lazy?`	`boolean`		If set to true, values will only be loaded if the related value isn't currently loaded.
`reuse_values?`	`boolean`		Whether calculations are allowed to reuse values that have already been loaded, or must refetch them from the data layer.
`strict?`	`boolean`		If set to true, only specified attributes will be loaded when passing a list of fields to fetch on a relationship, which allows for more optimized data-fetching.

reactor.load.actor

actor source

Specifies the action actor

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Element \| 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.load.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

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

Introspection

reactor.load.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Element \| 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.load.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.Load

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
context
inputs
load
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.Element \| 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.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the context 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.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Element \| 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.load

load source

Allows the addition of an Ash load statement to the action

Arguments

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

Options

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

Introspection

reactor.read_one.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Element \| 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
context
inputs
load
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.Element \| 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.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

Name	Type	Default	Docs
`transform`	`(any -> any) \| module \| nil`		An optional transformation function which can be used to modify the context 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.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Element \| 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.load

load source

Allows the addition of an Ash load statement to the action

Arguments

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

Options

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

Introspection

reactor.read.tenant

tenant source

Specifies the action tenant

Arguments

Name	Type	Default	Docs
`source`	`Reactor.Template.Element \| 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
context
inputs
load
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.Element \| 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.Element \| 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.update.context

context context

A map to be merged into the action's context

Arguments

Name	Type	Default	Docs
`context`	`nil \| Reactor.Template.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value \| map`		A map to be merged into the action's context.

Options

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

Introspection

reactor.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.Element \| Reactor.Template.Input \| Reactor.Template.Result \| Reactor.Template.Value} \| keyword(Reactor.Template.Element \| 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.update.load

load source

Allows the addition of an Ash load statement to the action

Arguments

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

Options

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

Introspection