ash v1.24.1 Ash.Type behaviour View Source

This behaviour is a superset of the Ecto.Type behavior, that also contains api level information, like what kinds of filters are allowed. Eventually, this may be used for composite types or serialization.

Much better to use Ash.Type than to say @behaviour Ash.Type and define everything yourself.

Built in types

:map - Ash.Type.Map
:term - Ash.Type.Term
:atom - Ash.Type.Atom
:string - Ash.Type.String
:integer - Ash.Type.Integer
:boolean - Ash.Type.Boolean
:uuid - Ash.Type.UUID
:date - Ash.Type.Date
:utc_datetime - Ash.Type.UtcDatetime

Composite Types

Currently, the only composite type supported is a list type, specified via: {:array, Type}. The constraints available are:

:items - Constraints for the elements of the list. See the contained type's docs for more.
:min_length - A minimum length for the items
:max_length - A maximum length for the items
:nil_items? - Whether or not the list can contain nil items The default value is true.

Link to this section Summary

Types

constraint_error()

constraints()

t()

Functions

apply_constraints(type, term, constraints)

Confirms if a casted value matches the provided constraints.

ash_type?(module)

Returns true if the value is a builtin type or adopts the Ash.Type behaviour

builtin?(type)

cast_input(type, term)

Casts input (e.g. unknown) data to an instance of the type, or errors

cast_stored(type, term)

Casts a value from the data store to an instance of the type, or errors

constraints(type)

dump_to_native(type, term)

Casts a value from the Elixir type to a value that the data store can persist

ecto_type(type)

Returns the ecto compatible type for an Ash.Type.

equal?(type, left, right)

Determines if two values of a given type are equal.

get_type(value)

storage_type(type)

Returns the underlying storage type (the underlying type of the ecto type of the ash type)

Callbacks

apply_constraints(term, constraints)

cast_input(term)

cast_stored(term)

constraints()

dump_to_native(term)

ecto_type()

equal?(term, term)

storage_type()

Link to this section Types

constraint_error()

Specs

constraint_error() :: String.t() | {String.t(), Keyword.t()}

constraints()

Specs

constraints() :: Keyword.t()

t()

Specs

t() :: atom() | {:array, atom()}

Link to this section Functions

apply_constraints(type, term, constraints)

Specs

apply_constraints(t(), term(), constraints()) :: :ok | {:error, String.t()}

Confirms if a casted value matches the provided constraints.

ash_type?(module)

Specs

ash_type?(term()) :: boolean()

Returns true if the value is a builtin type or adopts the Ash.Type behaviour

builtin?(type)

cast_input(type, term)

Specs

cast_input(t(), term()) :: {:ok, term()} | {:error, Keyword.t()} | :error

Casts input (e.g. unknown) data to an instance of the type, or errors

Maps to Ecto.Type.cast/2

cast_stored(type, term)

Specs

cast_stored(t(), term()) :: {:ok, term()} | {:error, keyword()} | :error

Casts a value from the data store to an instance of the type, or errors

Maps to Ecto.Type.load/2

constraints(type)

Specs

constraints(t()) :: constraints()

dump_to_native(type, term)

Specs

dump_to_native(t(), term()) :: {:ok, term()} | {:error, keyword()} | :error

Casts a value from the Elixir type to a value that the data store can persist

Maps to Ecto.Type.dump/2

ecto_type(type)

Specs

ecto_type(t()) :: Ecto.Type.t()

Returns the ecto compatible type for an Ash.Type.

If you use Ash.Type, this is created for you. For builtin types this may return a corresponding ecto builtin type (atom)

equal?(type, left, right)

Specs

equal?(t(), term(), term()) :: boolean()

Determines if two values of a given type are equal.

Maps to Ecto.Type.equal?/3

get_type(value)

Specs

get_type(atom() | module()) :: atom() | module()

storage_type(type)

Specs

storage_type(t()) :: Ecto.Type.t()

Returns the underlying storage type (the underlying type of the ecto type of the ash type)

Link to this section Callbacks

apply_constraints(term, constraints)

Specs

apply_constraints(term(), constraints()) ::
  :ok | {:error, constraint_error() | [constraint_error()]}

cast_input(term)

Specs

cast_input(term()) :: {:ok, term()} | {:error, Keyword.t()} | :error

cast_stored(term)

Specs

cast_stored(term()) :: {:ok, term()} | :error

constraints()

Specs

constraints() :: constraints()

dump_to_native(term)

Specs

dump_to_native(term()) :: {:ok, term()} | :error

ecto_type()

Specs

ecto_type() :: Ecto.Type.t()

equal?(term, term)

Specs

equal?(term(), term()) :: boolean()

storage_type()

Specs

storage_type() :: Ecto.Type.t()