#
View Source Ash.Api behaviour (ash v2.14.2)

An Api allows you to interact with your resources, and holds non-resource-specific configuration.

For example, the json api extension adds an api extension that lets you toggle authorization on/off for all resources in that Api. You include them in an Api like so:

    defmodule MyApp.Registry do
      use Ash.Registry

      entries do
        entry OneResource
        entry SecondResource
      end
    end

    defmodule MyApp.Api do
      use Ash.Api

      resources do
        registry MyApp.Registry
      end
    end

Then you can interact through that Api with the actions that those resources expose. For example: `MyApp.Api.create(changeset)`, or `MyApp.Api.read(query)`. Corresponding actions must be defined in your resources in order to call them through the Api.

##

interface

Interface

The functions documented here can be used to call any action on any resource in the Api. For example, `MyApi.read(Myresource, [...])`.

Additionally, you can define a `code_interface` on each resource. See the code interface guide for more.

# Link to this section Summary

## Types

load_statement()
page_request()
t()

## Callbacks

avg!(t, field, opts)

Get the avg of a given field from the given query, raising any errors

avg(t, field, opts)

Get the avg of a given field from the given query

bulk_create!( list, resource, action, params )

Creates many records, raising on any errors. See `bulk_create/2` for more.

bulk_create( list, resource, action, params )

Creates many records.

calculate!(resource, calculation, opts)
calculate(resource, calculation, opts)
can( action_or_query_or_changeset, actor )
can( action_or_query_or_changeset, actor, opts )

Returns wether or not the user can perform the action, or `:maybe`, returning any errors.

can?( query_or_changeset_or_action, actor )
can?( query_or_changeset_or_action, actor, opts )

Returns wether or not the user can perform the action, or raises on errors.

count!(t, opts)
count(t, opts)
create!(t, params)

Create a record. See `create/2` for more information.

create(t, params)

Create a record.

destroy!(arg1, params)

Destroy a record. See `destroy/2` for more information.

destroy(arg1, params)

Destroy a record.

exists(t, opts)

Wether or not the given query would return any results

exists?(t, opts)

Wether or not the given query would return any results, raising any errors

first!(t, field, opts)

Get the first of a given field from the given query, raising any errors

first(t, field, opts)

Get the first of a given field from the given query

get!( resource, id_or_filter, params )

Get a record by a primary key. See `get/3` for more.

get( resource, id_or_filter, params )

Get a record by a primary key.

list!(t, field, opts)

Get the list of a given field from the given query, raising any errors

list(t, field, opts)

Get list of a given field from the given query

load!( record_or_records, query, opts )

Load fields or relationships on already fetched records. See `load/3` for more information.

load( record_or_records, query, opts )

Load fields or relationships on already fetched records.

max!(t, field, opts)

Get the max of a given field from the given query, raising any errors

max(t, field, opts)

Get the max of a given field from the given query

min!(t, field, opts)

Get the min of a given field from the given query, raising any errors

min(t, field, opts)

Get the min of a given field from the given query

page!(page, page_request)

Fetch a page relative to the provided page.

page(page, page_request)

Fetch a page relative to the provided page.

read!(arg1, params)

Run an ash query. See `read/2` for more.

read(t, params)

Run a query on a resource.

read_one!(arg1, params)

Run an ash query, raising on more than one result. See `read_one/2` for more.

read_one(arg1, params)

Run a query on a resource, but fail on more than one result.

reload!(record, params)

Refetches a record by primary key. See `reload/1` for more.

reload(record)

Refetches a record by primary key.

run_action!(input, opts)

Runs a generic action, raising on errors

run_action(input, opts)

Runs a generic action

stream!(t, opts)

Streams the results of a query.

sum!(t, field, opts)

Get the sum of a given field from the given query, raising any errors

sum(t, field, opts)

Get the sum of a given field from the given query

update!(t, params)

Update a record. See `update/2` for more information.

update(t, params)

Update a record.

## Functions

aggregate(api, query, aggregate_or_aggregates, opts \\ [])

Runs an aggregate or aggregates over a resource query

allow(api) deprecated

See `Ash.Api.Info.allow/1`.

allow_unregistered?(api) deprecated

See `Ash.Api.Info.allow_unregistered?/1`.

authorize(api) deprecated

See `Ash.Api.Info.authorize/1`.

calculate(resource_or_record, calculation, opts \\ [])

Evaluates the calculation on the resource.

can(api, action_or_query_or_changeset, actor, opts \\ [])
can?(api, action_or_query_or_changeset, actor, opts \\ [])
destroy_opts_schema()
registry(api) deprecated

See `Ash.Api.Info.registry/1`.

require_actor?(api) deprecated

See `Ash.Api.Info.require_actor?/1`.

resource(api, resource) deprecated

See `Ash.Api.Info.resource/2`.

resources(api) deprecated

See `Ash.Api.Info.resources/1`.

run_action!(api, input, opts \\ [])
run_action(api, input, opts \\ [])

Runs a generic action.

stream!(api, query, opts \\ [])
timeout(api) deprecated

See `Ash.Api.Info.timeout/1`.

# Link to this section Types

Link to this type

# load_statement()

View Source

    @type load_statement() ::
      Ash.Query.t()
      | [atom()]
      | atom()
      | Keyword.t()
      | [atom() | {atom(), atom() | Keyword.t()}]

Link to this type

# page_request()

View Source

    @type page_request() :: :next | :prev | :first | :last | integer()

Link to this type

# t()

View Source

    @type t() :: module()

# Link to this section Callbacks

Link to this callback

# avg!(t, field, opts)

View Source

    @callback avg!(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      term() | no_return()

Get the avg of a given field from the given query, raising any errors

Link to this callback

# avg(t, field, opts)

View Source

    @callback avg(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      {:ok, term()} | {:error, Ash.Error.t()}

Get the avg of a given field from the given query

Link to this callback

# bulk_create!( list, resource, action, params )

View Source

    @callback bulk_create!(
      [map()],
      resource :: Ash.Resource.t(),
      action :: atom(),
      params :: Keyword.t()
    ) :: Ash.BulkResult.t() | no_return()

Creates many records, raising on any errors. See `bulk_create/2` for more.

- `:upsert?` (`boolean/0`) - If a conflict is found based on the primary key, the record is updated in the database (requires upsert support) The default value is `false`.

- `:upsert_identity` (`atom/0`) - The identity to use when detecting conflicts for `upsert?`, e.g. `upsert_identity: :full_name`. By default, the primary key is used. Has no effect if `upsert?: true` is not provided

- `:upsert_fields` (list of `atom/0`) - The fields to upsert. If not set, the action's `upsert_fields` is used. Unlike singular `create`, `bulk_create` with `upsert?` requires that `upsert_fields` be specified explicitly in one of these two locations.

- `:sorted?` (`boolean/0`) - Wether or not to sort results by their input position, in cases where `return_records?: true` was provided. The default value is `false`.

- `:return_records?` (`boolean/0`) - Wether or not to return all of the records that were inserted. Defaults to false to account for large inserts. The default value is `false`.

- `:return_errors?` (`boolean/0`) - Wether or not to return all of the errors that occur. Defaults to false to account for large inserts. The default value is `false`.

- `:batch_size` (`pos_integer/0`) - The number of records to include in each batch. Defaults to the `default_limit` or `max_page_size` of the action, or 100.

- `:return_stream?` (`boolean/0`) - If set to `true`, instead of an `Ash.BulkResult`, a mixed stream is returned.
  Potential elements:
  `{:notification, notification}` - if `return_notifications?` is set to `true` `{:ok, record}` - if `return_records?` is set to `true` `{:error, error}` - an error that occurred. May be changeset or an invidual error. The default value is `false`.

- `:stop_on_error?` (`boolean/0`) - If true, the first encountered error will stop the action and be returned. Otherwise, errors will be skipped. The default value is `false`.

- `:notify?` (`boolean/0`) - Wether or not to send notifications out. If this is set to `true` then the data layer must return the results from each batch. This may be intensive for large bulk actions. The default value is `false`.

- `:transaction` - Wether or not to wrap the entire execution in a transaction, each batch, or not at all.
  Keep in mind:
  `before_transaction` and `after_transaction` hooks attached to changesets will have to be run inside the transaction if you choose `transaction: :all`. Valid values are :all, :batch, false The default value is `:batch`.

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

- `:return_notifications?` (`boolean/0`) - Use this if you're running ash actions in your own transaction and you want notifications to happen still.
  If a transaction is ongoing, and this is false, notifications will be discarded, otherwise the return value is `{:ok, result, notifications}` (or `{:ok, notifications}`)
  To send notifications later, use `Ash.Notifier.notify(notifications)`. It sends any notifications that can be sent, and returns the rest. The default value is `false`.

- `:notification_metadata` (`term/0`) - Metadata to be merged into the metadata field for all notifications sent from this operation. The default value is `%{}`.

Link to this callback

# bulk_create( list, resource, action, params )

View Source

    @callback bulk_create(
      [map()],
      resource :: Ash.Resource.t(),
      action :: atom(),
      params :: Keyword.t()
    ) ::
      Ash.BulkResult.t()
      | Enumerable.t(
          {:ok, Ash.Resource.record()}
          | {:error, Ash.Changeset.t() | Ash.Error.t()}
          | {:notification, Ash.Notifier.Notification.t()}
        )

Creates many records.

##

assumptions

Assumptions

We assume that the input is a list of changesets all for the same action, or a list of input maps for the same action with the `:resource` and `:action` option provided to illustrate which action it is for.

##

performance-feasibility

Performance/Feasibility

The performance of this operation depends on the data layer in question. Data layers like AshPostgres will choose reasonable batch sizes in an attempt to handle large bulk actions, but that does not mean that you can pass a list of 500k inputs and expect things to go off without a hitch (although it might). If you need to do large data processing, you should look into projects like GenStage and Broadway. With that said, if you want to do things like support CSV upload and you place some reasonable limits on the size this is a great tool. You'll need to test it yourself, YMMV.

Passing `return_records?: true` can significantly increase the time it takes to perform the operation, and can also make the operation completely unreasonable due to the memory requirement. If you want to do very large bulk creates and display all of the results, the suggestion is to annotate them with a "bulk_create_id" in the data layer, and then read the records with that `bulk_create_id` so that they can be retrieved later if necessary.

##

changes-validations

Changes/Validations

Changes will be applied in the order they are given on the actions as normal. Any change that exposes the `bulk_change` or `bulk_validate` callback will be applied on the entire list.

##

after-action-hooks

After Action Hooks

The following requirements must be met for `after_action` hooks to function properly. If they are not met, and an after_action hook being applied to a changeset in a `change`.

1. `return_records?` must be set to `true`.
2. The changeset must be setting the primary key as part of its changes, so that we know which result applies to which changeset.

It is possible to use `after_action` hooks with `bulk_change/3`, but you need to return the hooks along with the changesets. This allows for setting up `after_action` hooks that don't need access to the returned record, or `after_action` hooks that can operate on the entire list at once. See the documentation for that callback for more on how to do accomplish that.

- `:upsert?` (`boolean/0`) - If a conflict is found based on the primary key, the record is updated in the database (requires upsert support) The default value is `false`.

- `:upsert_identity` (`atom/0`) - The identity to use when detecting conflicts for `upsert?`, e.g. `upsert_identity: :full_name`. By default, the primary key is used. Has no effect if `upsert?: true` is not provided

- `:upsert_fields` (list of `atom/0`) - The fields to upsert. If not set, the action's `upsert_fields` is used. Unlike singular `create`, `bulk_create` with `upsert?` requires that `upsert_fields` be specified explicitly in one of these two locations.

- `:sorted?` (`boolean/0`) - Wether or not to sort results by their input position, in cases where `return_records?: true` was provided. The default value is `false`.

- `:return_records?` (`boolean/0`) - Wether or not to return all of the records that were inserted. Defaults to false to account for large inserts. The default value is `false`.

- `:return_errors?` (`boolean/0`) - Wether or not to return all of the errors that occur. Defaults to false to account for large inserts. The default value is `false`.

- `:batch_size` (`pos_integer/0`) - The number of records to include in each batch. Defaults to the `default_limit` or `max_page_size` of the action, or 100.

- `:return_stream?` (`boolean/0`) - If set to `true`, instead of an `Ash.BulkResult`, a mixed stream is returned.
  Potential elements:
  `{:notification, notification}` - if `return_notifications?` is set to `true` `{:ok, record}` - if `return_records?` is set to `true` `{:error, error}` - an error that occurred. May be changeset or an invidual error. The default value is `false`.

- `:stop_on_error?` (`boolean/0`) - If true, the first encountered error will stop the action and be returned. Otherwise, errors will be skipped. The default value is `false`.

- `:notify?` (`boolean/0`) - Wether or not to send notifications out. If this is set to `true` then the data layer must return the results from each batch. This may be intensive for large bulk actions. The default value is `false`.

- `:transaction` - Wether or not to wrap the entire execution in a transaction, each batch, or not at all.
  Keep in mind:
  `before_transaction` and `after_transaction` hooks attached to changesets will have to be run inside the transaction if you choose `transaction: :all`. Valid values are :all, :batch, false The default value is `:batch`.

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

- `:return_notifications?` (`boolean/0`) - Use this if you're running ash actions in your own transaction and you want notifications to happen still.
  If a transaction is ongoing, and this is false, notifications will be discarded, otherwise the return value is `{:ok, result, notifications}` (or `{:ok, notifications}`)
  To send notifications later, use `Ash.Notifier.notify(notifications)`. It sends any notifications that can be sent, and returns the rest. The default value is `false`.

- `:notification_metadata` (`term/0`) - Metadata to be merged into the metadata field for all notifications sent from this operation. The default value is `%{}`.

Link to this callback

# calculate!(resource, calculation, opts)

View Source

    @callback calculate!(
      resource :: Ash.Resource.t(),
      calculation :: atom(),
      opts :: Keyword.t()
    ) ::
      term() | no_return()

    @callback calculate!(
      resource :: Ash.Resource.t(),
      calculation :: atom(),
      opts :: Keyword.t()
    ) ::
      term() | no_return()

Link to this callback

# calculate(resource, calculation, opts)

View Source

    @callback calculate(
      resource :: Ash.Resource.t(),
      calculation :: atom(),
      opts :: Keyword.t()
    ) ::
      {:ok, term()} | {:error, term()}

Link to this callback

# can( action_or_query_or_changeset, actor )

View Source

    @callback can(
      action_or_query_or_changeset ::
        Ash.Query.t()
        | Ash.Changeset.t()
        | {Ash.Resource.t(), atom() | Ash.Resource.Actions.action()},
      actor :: term()
    ) :: {:ok, boolean() | :maybe} | {:error, term()}

Link to this callback

# can( action_or_query_or_changeset, actor, opts )

View Source

    @callback can(
      action_or_query_or_changeset ::
        Ash.Query.t()
        | Ash.Changeset.t()
        | {Ash.Resource.t(), atom() | Ash.Resource.Actions.action()},
      actor :: term(),
      opts :: Keyword.t()
    ) :: {:ok, boolean() | :maybe} | {:error, term()}

Returns wether or not the user can perform the action, or `:maybe`, returning any errors.

In cases with "runtime" checks (checks after the action), we may not be able to determine an answer, and so the value `:maybe` will be returned from `can/2`. The `can?` function assumes that `:maybe` means `true`. Keep in mind, this is just for doing things like "can they do this" in a UI, so assuming `:maybe` is `true` is fine. The actual action invocation will be properly checked regardless. If you have runtime checks, you may need to use `can` instead of `can?`, or configure what `:maybe` means.

##

options

Options

- `maybe_is` - What to treat `:maybe` results as, defaults to `true` if using `can?`, or `:maybe` if using `can`.
- `run_queries?` - In order to determine authorization status for changesets that use filter checks, we may need to run queries (almost always only one query). Set this to `false` to disable (returning `:maybe` instead). The default value is `true`.
- `data` - A record or list of records. For authorizing reads with filter checks, this can be provided and a filter check will only be `true` if all records match the filter. This is detected by running a query.

Link to this callback

# can?( query_or_changeset_or_action, actor )

View Source

    @callback can?(
      query_or_changeset_or_action ::
        Ash.Query.t()
        | Ash.Changeset.t()
        | {Ash.Resource.t(), atom() | Ash.Resource.Actions.action()},
      actor :: term()
    ) :: boolean() | no_return()

Link to this callback

# can?( query_or_changeset_or_action, actor, opts )

View Source

    @callback can?(
      query_or_changeset_or_action ::
        Ash.Query.t()
        | Ash.Changeset.t()
        | {Ash.Resource.t(), atom() | Ash.Resource.Actions.action()},
      actor :: term(),
      opts :: Keyword.t()
    ) :: boolean() | no_return()

Returns wether or not the user can perform the action, or raises on errors.

See `can/3` for more info.

Link to this callback

# count!(t, opts)

View Source

    @callback count!(Ash.Query.t(), opts :: Keyword.t()) :: integer() | no_return()

Link to this callback

# count(t, opts)

View Source

    @callback count(Ash.Query.t(), opts :: Keyword.t()) ::
      {:ok, integer()} | {:error, Ash.Error.t()}

Link to this callback

# create!(t, params)

View Source

    @callback create!(Ash.Changeset.t(), params :: Keyword.t()) ::
      Ash.Resource.record()
      | {Ash.Resource.record(), [Ash.Notifier.Notification.t()]}
      | no_return()

Create a record. See `create/2` for more information.

Link to this callback

# create(t, params)

View Source

    @callback create(Ash.Changeset.t(), params :: Keyword.t()) ::
      {:ok, Ash.Resource.record()}
      | {:ok, Ash.Resource.record(), [Ash.Notifier.Notification.t()]}
      | {:error, term()}

Create a record.

- `:upsert?` (`boolean/0`) - If a conflict is found based on the primary key, the record is updated in the database (requires upsert support) The default value is `false`.

- `:upsert_identity` (`atom/0`) - The identity to use when detecting conflicts for `upsert?`, e.g. `upsert_identity: :full_name`. By default, the primary key is used. Has no effect if `upsert?: true` is not provided

- `:upsert_fields` (list of `atom/0`) - The fields to upsert. If not set, the action's upsert_fields is used, and if that is not set, then any fields not being set to defaults are written.

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:action` (`term/0`) - The action to use, either an Action struct or the name of the action

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

- `:after_action` (`term/0`) - A hook to be run just before the action returns, but before fields are selected (still inside the same transaction, if your data layer supports transactions). This is mostly important if you want to load calculations after the action, which depend on having fields selected, but you want to authorize with the minimal set of fields that are actually being selected. Runs only if the action is successful, and is passed the changeset and result of the action. Should return `{:ok, result}` or `{:error, error}`.
  For example, if you had a `full_name` calculation, but were only selecting, `first_name` and `full_name`, you might do something like this:

        MyApp.User
        |> Ash.Changeset.for_create(:create, %{first_name: "first_name", last_name: "last_name"}
        |> Ash.Changeset.select(:first_name))
        |> Api.create(after_action: fn _changeset, user -> Api.load(user, :full_name) end)

  If you tried to load that `:full_name` calculation after receiving the data, the `last_name` would not be selected and as such would not be usable in the calculation, regardless of whether or not the calculation includes that field in its select list.

- `:return_notifications?` (`boolean/0`) - Use this if you're running ash actions in your own transaction and you want notifications to happen still.
  If a transaction is ongoing, and this is false, notifications will be discarded, otherwise the return value is `{:ok, result, notifications}` (or `{:ok, notifications}`)
  To send notifications later, use `Ash.Notifier.notify(notifications)`. It sends any notifications that can be sent, and returns the rest. The default value is `false`.

- `:notification_metadata` (`term/0`) - Metadata to be merged into the metadata field for all notifications sent from this operation. The default value is `%{}`.

Link to this callback

# destroy!(arg1, params)

View Source

    @callback destroy!(Ash.Changeset.t() | Ash.Resource.record(), params :: Keyword.t()) ::
      :ok
      | Ash.Resource.record()
      | [Ash.Notifier.Notification.t()]
      | {Ash.Resource.record(), [Ash.Notifier.Notification.t()]}
      | no_return()

Destroy a record. See `destroy/2` for more information.

Link to this callback

# destroy(arg1, params)

View Source

    @callback destroy(Ash.Changeset.t() | Ash.Resource.record(), params :: Keyword.t()) ::
      :ok
      | {:ok, Ash.Resource.record()}
      | {:ok, [Ash.Notifier.Notification.t()]}
      | {:ok, Ash.Resource.record(), [Ash.Notifier.Notification.t()]}
      | {:error, term()}

Destroy a record.

- `:return_destroyed?` (`boolean/0`) - If true, the destroyed record is included in the return result, e.g `{:ok, destroyed}` or `{:ok, destroyed, notifications}` The default value is `false`.

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:action` (`term/0`) - The action to use, either an Action struct or the name of the action

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

- `:return_notifications?` (`boolean/0`) - Use this if you're running ash actions in your own transaction and you want notifications to happen still.
  If a transaction is ongoing, and this is false, notifications will be discarded, otherwise the return value is `{:ok, result, notifications}` (or `{:ok, notifications}`)
  To send notifications later, use `Ash.Notifier.notify(notifications)`. It sends any notifications that can be sent, and returns the rest. The default value is `false`.

- `:notification_metadata` (`term/0`) - Metadata to be merged into the metadata field for all notifications sent from this operation. The default value is `%{}`.

Link to this callback

# exists(t, opts)

View Source

    @callback exists(Ash.Query.t(), opts :: Keyword.t()) ::
      {:ok, boolean()} | {:error, Ash.Error.t()}

Wether or not the given query would return any results

Link to this callback

# exists?(t, opts)

View Source

    @callback exists?(Ash.Query.t(), opts :: Keyword.t()) :: boolean() | no_return()

Wether or not the given query would return any results, raising any errors

Link to this callback

# first!(t, field, opts)

View Source

    @callback first!(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      term() | no_return()

Get the first of a given field from the given query, raising any errors

Link to this callback

# first(t, field, opts)

View Source

    @callback first(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      {:ok, term()} | {:error, Ash.Error.t()}

Get the first of a given field from the given query

Link to this callback

# get!( resource, id_or_filter, params )

View Source

    @callback get!(
      resource :: Ash.Resource.t(),
      id_or_filter :: term(),
      params :: Keyword.t()
    ) :: Ash.Resource.record() | no_return()

Get a record by a primary key. See `get/3` for more.

Link to this callback

# get( resource, id_or_filter, params )

View Source

    @callback get(
      resource :: Ash.Resource.t(),
      id_or_filter :: term(),
      params :: Keyword.t()
    ) :: {:ok, Ash.Resource.record()} | {:ok, nil} | {:error, term()}

Get a record by a primary key.

For a resource with a composite primary key, pass a keyword list, e.g `MyApi.get(MyResource, first_key: 1, second_key: 2)`

- `:error?` (`boolean/0`) - Whether or not an error should be returned or raised when the record is not found. If set to false, `nil` will be returned. The default value is `true`.

- `:load` (`term/0`) - Fields or relationships to load in the query. See `Ash.Query.load/2`

- `:lock` (`term/0`) - A lock statement to add onto the query

- `:context` (`term/0`) - Context to be set on the query being run

- `:reselect_all?` (`boolean/0`) - Wether or not to reselect all attributes depended on by loads. By default, we only reselect fields that weren't already selected. The default value is `false`.

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:action` (`term/0`) - The action to use, either an Action struct or the name of the action

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

Link to this callback

# list!(t, field, opts)

View Source

    @callback list!(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      [term()] | no_return()

Get the list of a given field from the given query, raising any errors

Link to this callback

# list(t, field, opts)

View Source

    @callback list(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      {:ok, [term()]} | {:error, Ash.Error.t()}

Get list of a given field from the given query

Link to this callback

# load!( record_or_records, query, opts )

View Source

    @callback load!(
      record_or_records :: Ash.Resource.record() | [Ash.Resource.record()],
      query :: load_statement(),
      opts :: Keyword.t()
    ) :: Ash.Resource.record() | [Ash.Resource.record()] | no_return()

Load fields or relationships on already fetched records. See `load/3` for more information.

Link to this callback

# load( record_or_records, query, opts )

View Source

    @callback load(
      record_or_records :: Ash.Resource.record() | [Ash.Resource.record()],
      query :: load_statement(),
      opts :: Keyword.t()
    ) :: {:ok, Ash.Resource.record() | [Ash.Resource.record()]} | {:error, term()}

Load fields or relationships on already fetched records.

Accepts a list of non-loaded fields and loads them on the provided records or a query, in which case the loaded fields of the query are used. Relationship loads can be nested, for example: `MyApi.load(record, [posts: [:comments]])`.

- `:lazy?` (`boolean/0`) - If set to true, values will only be loaded if the related value isn't currently loaded. The default value is `false`.

- `:reselect_all?` (`boolean/0`) - Wether or not to reselect all attributes depended on by loads. By default, we only reselect fields that weren't already selected. The default value is `false`.

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:action` (`term/0`) - The action to use, either an Action struct or the name of the action

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

Link to this callback

# max!(t, field, opts)

View Source

    @callback max!(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      term() | no_return()

Get the max of a given field from the given query, raising any errors

Link to this callback

# max(t, field, opts)

View Source

    @callback max(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      {:ok, term()} | {:error, Ash.Error.t()}

Get the max of a given field from the given query

Link to this callback

# min!(t, field, opts)

View Source

    @callback min!(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      term() | no_return()

Get the min of a given field from the given query, raising any errors

Link to this callback

# min(t, field, opts)

View Source

    @callback min(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      {:ok, term()} | {:error, Ash.Error.t()}

Get the min of a given field from the given query

Link to this callback

# page!(page, page_request)

View Source

    @callback page!(Ash.Page.page(), page_request()) :: Ash.Page.page() | no_return()

Fetch a page relative to the provided page.

Link to this callback

# page(page, page_request)

View Source

    @callback page(Ash.Page.page(), page_request()) ::
      {:ok, Ash.Page.page()} | {:error, term()}

Fetch a page relative to the provided page.

A page is the return value of a paginated action called via `read/2`.

Link to this callback

# read!(arg1, params)

View Source

    @callback read!(Ash.Query.t() | Ash.Resource.t(), params :: Keyword.t()) ::
      [Ash.Resource.record()]
      | {[Ash.Resource.record()], Ash.Query.t()}
      | no_return()

Run an ash query. See `read/2` for more.

Link to this callback

# read(t, params)

View Source

    @callback read(Ash.Query.t(), params :: Keyword.t()) ::
      {:ok, [Ash.Resource.record()]}
      | {:ok, [Ash.Resource.record()], Ash.Query.t()}
      | {:error, term()}

Run a query on a resource.

For more information on building a query, see `Ash.Query`.

- `:page` - Pagination options, see the pagination docs for more

- `:load` (`term/0`) - A load statement to add onto the query

- `:lock` (`term/0`) - A lock statement to add onto the query

- `:return_query?` (`boolean/0`) - If `true`, the query that was ultimately used is returned as a third tuple element.
  The query goes through many potential changes during a request, potentially adding authorization filters, or replacing relationships for other data layers with their corresponding ids. This option can be used to get the true query that was sent to the data layer. The default value is `false`.

- `:reselect_all?` (`boolean/0`) - Wether or not to reselect all attributes depended on by loads. By default, we only reselect fields that weren't already selected. The default value is `false`.

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:action` (`term/0`) - The action to use, either an Action struct or the name of the action

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

##

pagination

Pagination

#### Limit/offset pagination

- `:offset` (`non_neg_integer/0`) - The number of records to skip from the beginning of the query

- `:limit` (`pos_integer/0`) - The number of records to include in the page

- `:filter` (`term/0`) - A filter to apply for pagination purposes, that should not be considered in the full count.
  This is used by the liveview paginator to only fetch the records that were already on the page when refreshing data, to avoid pages jittering.

- `:count` (`boolean/0`) - Whether or not to return the page with a full count of all records

#### Keyset pagination

- `:before` (`String.t/0`) - Get records that appear before the provided keyset (mutually exclusive with `after`)

- `:after` (`String.t/0`) - Get records that appear after the provided keyset (mutually exclusive with `before`)

- `:limit` (`pos_integer/0`) - How many records to include in the page

- `:filter` (`term/0`) - See the `filter` option for offset pagination, this behaves the same.

- `:count` (`boolean/0`) - Whether or not to return the page with a full count of all records

Link to this callback

# read_one!(arg1, params)

View Source

    @callback read_one!(Ash.Query.t() | Ash.Resource.t(), params :: Keyword.t()) ::
      Ash.Resource.record()
      | {Ash.Resource.record(), Ash.Query.t()}
      | nil
      | no_return()

Run an ash query, raising on more than one result. See `read_one/2` for more.

Link to this callback

# read_one(arg1, params)

View Source

    @callback read_one(Ash.Query.t() | Ash.Resource.t(), params :: Keyword.t()) ::
      {:ok, Ash.Resource.record()}
      | {:ok, Ash.Resource.record(), Ash.Query.t()}
      | {:ok, nil}
      | {:error, term()}

Run a query on a resource, but fail on more than one result.

This is useful if you have a query that doesn't include a primary key but you know that it will only ever return a single result.

Link to this callback

# reload!(record, params)

View Source

    @callback reload!(record :: Ash.Resource.record(), params :: Keyword.t()) ::
      Ash.Resource.record() | no_return()

Refetches a record by primary key. See `reload/1` for more.

Link to this callback

# reload(record)

View Source

    @callback reload(record :: Ash.Resource.record()) ::
      {:ok, Ash.Resource.record()} | {:error, term()}

Refetches a record by primary key.

Link to this callback

# run_action!(input, opts)

View Source

    @callback run_action!(input :: Ash.ActionInput.t(), opts :: Keyword.t()) ::
      term() | no_return()

Runs a generic action, raising on errors

Link to this callback

# run_action(input, opts)

View Source

    @callback run_action(input :: Ash.ActionInput.t(), opts :: Keyword.t()) ::
      {:ok, term()} | {:error, term()}

Runs a generic action

Link to this callback

# stream!(t, opts)

View Source

    @callback stream!(Ash.Query.t(), opts :: Keyword.t()) ::
      Enumerable.t(Ash.Resource.record())

Streams the results of a query.

This utilizes keyset pagination to accomplish this stream, and for that reason, the action for the query must support keyset pagination.

Link to this callback

# sum!(t, field, opts)

View Source

    @callback sum!(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      term() | no_return()

Get the sum of a given field from the given query, raising any errors

Link to this callback

# sum(t, field, opts)

View Source

    @callback sum(Ash.Query.t(), field :: atom(), opts :: Keyword.t()) ::
      {:ok, term()} | {:error, Ash.Error.t()}

Get the sum of a given field from the given query

Link to this callback

# update!(t, params)

View Source

    @callback update!(Ash.Changeset.t(), params :: Keyword.t()) ::
      Ash.Resource.record()
      | {Ash.Resource.record(), [Ash.Notifier.Notification.t()]}
      | no_return()

Update a record. See `update/2` for more information.

Link to this callback

# update(t, params)

View Source

    @callback update(Ash.Changeset.t(), params :: Keyword.t()) ::
      {:ok, Ash.Resource.record()}
      | {:ok, Ash.Resource.record(), [Ash.Notifier.Notification.t()]}
      | {:error, term()}

Update a record.

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:action` (`term/0`) - The action to use, either an Action struct or the name of the action

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

- `:after_action` (`term/0`) - A hook to be run just before the action returns, but before fields are selected (still inside the same transaction, if your data layer supports transactions). This is mostly important if you want to load calculations after the action, which depend on having fields selected, but you want to authorize with the minimal set of fields that are actually being selected. Runs only if the action is successful, and is passed the changeset and result of the action. Should return `{:ok, result}` or `{:error, error}`.
  For example, if you had a `full_name` calculation, but were only selecting, `first_name` and `full_name`, you might do something like this:

        MyApp.User
        |> Ash.Changeset.for_create(:create, %{first_name: "first_name", last_name: "last_name"}
        |> Ash.Changeset.select(:first_name))
        |> Api.create(after_action: fn _changeset, user -> Api.load(user, :full_name) end)

  If you tried to load that `:full_name` calculation after receiving the data, the `last_name` would not be selected and as such would not be usable in the calculation, regardless of whether or not the calculation includes that field in its select list.

- `:return_notifications?` (`boolean/0`) - Use this if you're running ash actions in your own transaction and you want notifications to happen still.
  If a transaction is ongoing, and this is false, notifications will be discarded, otherwise the return value is `{:ok, result, notifications}` (or `{:ok, notifications}`)
  To send notifications later, use `Ash.Notifier.notify(notifications)`. It sends any notifications that can be sent, and returns the rest. The default value is `false`.

- `:notification_metadata` (`term/0`) - Metadata to be merged into the metadata field for all notifications sent from this operation. The default value is `%{}`.

# Link to this section Functions

Link to this function

# aggregate(api, query, aggregate_or_aggregates, opts \\ [])

View Source

Runs an aggregate or aggregates over a resource query

- `:timeout` (`timeout/0`) - A positive integer, or `:infinity`. If none is provided, the timeout configured on the api is used (which defaults to `30_000`).

- `:tracer` (`atom/0`) - A tracer that implements the `Ash.Tracer` behaviour. See that module for more.

- `:verbose?` (`boolean/0`) - Log engine operations (very verbose!) The default value is `false`.

- `:action` (`term/0`) - The action to use, either an Action struct or the name of the action

- `:authorize?` - If an actor option is provided (even if it is `nil`), authorization happens automatically. If not, this flag can be used to authorize with no user. Valid values are true, false, nil

- `:stacktraces?` (`boolean/0`) - For Ash errors, whether or not each error has a stacktrace. See the error_handling guide for more. The default value is `true`.

- `:tenant` (`term/0`) - A tenant to set on the query or changeset

- `:actor` (`term/0`) - If an actor is provided, it will be used in conjunction with the authorizers of a resource to authorize access

Link to this function

# allow(api)

View Source
This function is deprecated. use Ash.Api.Info.allow/1 instead.

See `Ash.Api.Info.allow/1`.

Link to this function

# allow_unregistered?(api)

View Source
This function is deprecated. use Ash.Api.Info.allow_unregistered?/1 instead.

See `Ash.Api.Info.allow_unregistered?/1`.

Link to this function

# authorize(api)

View Source
This function is deprecated. use Ash.Api.Info.authorize/1 instead.

See `Ash.Api.Info.authorize/1`.

Link to this function

# calculate(resource_or_record, calculation, opts \\ [])

View Source

Evaluates the calculation on the resource.

If a record is provided, its field values will be used to evaluate the calculation.

- `:args` (`map/0`) - Values for arguments referenced by the calculation. The default value is `%{}`.

- `:refs` (`map/0`) - Values for references used by the calculation. The default value is `%{}`.

- `:actor` (`term/0`) - The actor for handling `^actor/1` templates, supplied to calculation context.

- `:tenant` (`term/0`) - The tenant, supplied to calculation context.

- `:authorize?` (`boolean/0`) - Wether or not the request is being authorized, provided to calculation context. The default value is `true`.

- `:tracer` (`term/0`) - A tracer, provided to the calculation context.

- `:record` (`term/0`) - A record to use as the base of the calculation

Link to this function

# can(api, action_or_query_or_changeset, actor, opts \\ [])

View Source

    @spec can(
      api :: t(),
      action_or_query_or_changeset ::
        Ash.Query.t()
        | Ash.Changeset.t()
        | Ash.ActionInput.t()
        | {Ash.Resource.t(), atom() | Ash.Resource.Actions.action()}
        | {Ash.Resource.t(), atom() | Ash.Resource.Actions.action(), input :: map()},
      actor :: term(),
      opts :: Keyword.t()
    ) :: {:ok, boolean() | :maybe} | {:ok, false, Exception.t()} | {:error, term()}

Link to this function

# can?(api, action_or_query_or_changeset, actor, opts \\ [])

View Source

    @spec can?(
      api :: t(),
      query_or_changeset_or_action ::
        Ash.Query.t()
        | Ash.Changeset.t()
        | Ash.ActionInput.t()
        | {Ash.Resource.t(), atom() | Ash.Resource.Actions.action()}
        | {Ash.Resource.t(), atom() | Ash.Resource.Actions.action(), input :: map()},
      actor :: term(),
      opts :: Keyword.t()
    ) :: boolean() | no_return()

Link to this function

# destroy_opts_schema()

View Source
Link to this function

# registry(api)

View Source
This function is deprecated. use Ash.Api.Info.registry/1 instead.

See `Ash.Api.Info.registry/1`.

Link to this function

# require_actor?(api)

View Source
This function is deprecated. use Ash.Api.Info.require_actor?/1 instead.

See `Ash.Api.Info.require_actor?/1`.

Link to this function

# resource(api, resource)

View Source
This function is deprecated. use Ash.Api.Info.resource/2 instead.

See `Ash.Api.Info.resource/2`.

Link to this function

# resources(api)

View Source
This function is deprecated. use Ash.Api.Info.resources/1 instead.

See `Ash.Api.Info.resources/1`.

Link to this function

# run_action!(api, input, opts \\ [])

View Source

    @spec run_action!(api :: t(), input :: Ash.ActionInput.t(), opts :: Keyword.t()) ::
      term() | no_return()

Link to this function

# run_action(api, input, opts \\ [])

View Source

    @spec run_action(api :: t(), input :: Ash.ActionInput.t(), opts :: Keyword.t()) ::
      {:ok, term()} | {:error, Ash.Error.t()}

Runs a generic action.

Options:

- `:actor` (`term/0`) - The actor for handling `^actor/1` templates, supplied to calculation context.

- `:tenant` (`term/0`) - The tenant, supplied to calculation context.

- `:authorize?` (`boolean/0`) - Wether or not the request should be authorized.

- `:tracer` (`term/0`) - A tracer, provided to the calculation context.

Link to this function

# stream!(api, query, opts \\ [])

View Source

    @spec stream!(api :: module(), query :: Ash.Query.t(), opts :: Keyword.t()) ::
      Enumerable.t(Ash.Resource.record())

Link to this function

# timeout(api)

View Source
This function is deprecated. use Ash.Api.Info.timeout/1 instead.

See `Ash.Api.Info.timeout/1`.