Skuld.Repo.Effectful behaviour (skuld v0.28.0)

Effectful behaviour for Skuld.Repo.Contract.

Defines computation-returning callbacks for each Repo operation. Effectful implementations declare @behaviour Skuld.Repo.Effectful.

Summary

Callbacks

aggregate(queryable, aggregate, field)

aggregate(queryable, aggregate, field, opts)

all(queryable)

all(queryable, opts)

all_by(queryable, clauses)

all_by(queryable, clauses, opts)

delete(struct_or_changeset)

delete(struct_or_changeset, opts)

delete!(struct_or_changeset)

delete!(struct_or_changeset, opts)

delete_all(queryable, opts)

exists?(queryable)

exists?(queryable, opts)

get(queryable, id)

get(queryable, id, opts)

get!(queryable, id)

get!(queryable, id, opts)

get_by(queryable, clauses)

get_by(queryable, clauses, opts)

get_by!(queryable, clauses)

get_by!(queryable, clauses, opts)

insert(struct_or_changeset)

insert(struct_or_changeset, opts)

insert!(struct_or_changeset)

insert!(struct_or_changeset, opts)

insert_all(source, entries, opts)

insert_or_update(changeset)

insert_or_update(changeset, opts)

insert_or_update!(changeset)

insert_or_update!(changeset, opts)

load(schema_or_map, data)

one(queryable)

one(queryable, opts)

one!(queryable)

one!(queryable, opts)

preload(structs_or_struct_or_nil, preloads)

preload(structs_or_struct_or_nil, preloads, opts)

query(sql)

query(sql, params)

query(sql, params, opts)

query!(sql)

query!(sql, params)

query!(sql, params, opts)

reload(struct_or_structs)

reload(struct_or_structs, opts)

reload!(struct_or_structs)

reload!(struct_or_structs, opts)

stream(queryable)

stream(queryable, opts)

update(changeset)

update(changeset, opts)

update!(changeset)

update!(changeset, opts)

update_all(queryable, updates, opts)

Callbacks

aggregate(queryable, aggregate, field)

@callback aggregate(queryable :: Ecto.Queryable.t(), aggregate :: atom(), field :: atom()) ::
  Skuld.Comp.Types.computation(term())

aggregate(queryable, aggregate, field, opts)

@callback aggregate(
  queryable :: Ecto.Queryable.t(),
  aggregate :: atom(),
  field :: atom(),
  opts :: keyword()
) :: Skuld.Comp.Types.computation(term())

all(queryable)

@callback all(queryable :: Ecto.Queryable.t()) :: Skuld.Comp.Types.computation([struct()])

all(queryable, opts)

@callback all(queryable :: Ecto.Queryable.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation([struct()])

all_by(queryable, clauses)

@callback all_by(queryable :: Ecto.Queryable.t(), clauses :: keyword() | map()) ::
  Skuld.Comp.Types.computation([struct()])

all_by(queryable, clauses, opts)

@callback all_by(
  queryable :: Ecto.Queryable.t(),
  clauses :: keyword() | map(),
  opts :: keyword()
) ::
  Skuld.Comp.Types.computation([struct()])

delete(struct_or_changeset)

@callback delete(struct_or_changeset :: struct() | Ecto.Changeset.t()) ::
  Skuld.Comp.Types.computation({:ok, struct()} | {:error, Ecto.Changeset.t()})

delete(struct_or_changeset, opts)

@callback delete(struct_or_changeset :: struct() | Ecto.Changeset.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation({:ok, struct()} | {:error, Ecto.Changeset.t()})

delete!(struct_or_changeset)

@callback delete!(struct_or_changeset :: struct() | Ecto.Changeset.t()) ::
  Skuld.Comp.Types.computation(struct())

delete!(struct_or_changeset, opts)

@callback delete!(struct_or_changeset :: struct() | Ecto.Changeset.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct())

delete_all(queryable, opts)

@callback delete_all(queryable :: Ecto.Queryable.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation({non_neg_integer(), nil | list()})

exists?(queryable)

@callback exists?(queryable :: Ecto.Queryable.t()) ::
  Skuld.Comp.Types.computation(boolean())

exists?(queryable, opts)

@callback exists?(queryable :: Ecto.Queryable.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(boolean())

get(queryable, id)

@callback get(queryable :: Ecto.Queryable.t(), id :: term()) ::
  Skuld.Comp.Types.computation(struct() | nil)

get(queryable, id, opts)

@callback get(queryable :: Ecto.Queryable.t(), id :: term(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct() | nil)

get!(queryable, id)

@callback get!(queryable :: Ecto.Queryable.t(), id :: term()) ::
  Skuld.Comp.Types.computation(struct())

get!(queryable, id, opts)

@callback get!(queryable :: Ecto.Queryable.t(), id :: term(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct())

get_by(queryable, clauses)

@callback get_by(queryable :: Ecto.Queryable.t(), clauses :: keyword() | map()) ::
  Skuld.Comp.Types.computation(struct() | nil)

get_by(queryable, clauses, opts)

@callback get_by(
  queryable :: Ecto.Queryable.t(),
  clauses :: keyword() | map(),
  opts :: keyword()
) ::
  Skuld.Comp.Types.computation(struct() | nil)

get_by!(queryable, clauses)

@callback get_by!(queryable :: Ecto.Queryable.t(), clauses :: keyword() | map()) ::
  Skuld.Comp.Types.computation(struct())

get_by!(queryable, clauses, opts)

@callback get_by!(
  queryable :: Ecto.Queryable.t(),
  clauses :: keyword() | map(),
  opts :: keyword()
) ::
  Skuld.Comp.Types.computation(struct())

insert(struct_or_changeset)

@callback insert(struct_or_changeset :: Ecto.Changeset.t() | struct()) ::
  Skuld.Comp.Types.computation({:ok, struct()} | {:error, Ecto.Changeset.t()})

insert(struct_or_changeset, opts)

@callback insert(struct_or_changeset :: Ecto.Changeset.t() | struct(), opts :: keyword()) ::
  Skuld.Comp.Types.computation({:ok, struct()} | {:error, Ecto.Changeset.t()})

insert!(struct_or_changeset)

@callback insert!(struct_or_changeset :: Ecto.Changeset.t() | struct()) ::
  Skuld.Comp.Types.computation(struct())

insert!(struct_or_changeset, opts)

@callback insert!(struct_or_changeset :: Ecto.Changeset.t() | struct(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct())

insert_all(source, entries, opts)

@callback insert_all(
  source :: Ecto.Queryable.t() | binary(),
  entries :: [map() | keyword()],
  opts :: keyword()
) :: Skuld.Comp.Types.computation({non_neg_integer(), nil | list()})

insert_or_update(changeset)

@callback insert_or_update(changeset :: Ecto.Changeset.t()) ::
  Skuld.Comp.Types.computation({:ok, struct()} | {:error, Ecto.Changeset.t()})

insert_or_update(changeset, opts)

@callback insert_or_update(changeset :: Ecto.Changeset.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation({:ok, struct()} | {:error, Ecto.Changeset.t()})

insert_or_update!(changeset)

@callback insert_or_update!(changeset :: Ecto.Changeset.t()) ::
  Skuld.Comp.Types.computation(struct())

insert_or_update!(changeset, opts)

@callback insert_or_update!(changeset :: Ecto.Changeset.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct())

load(schema_or_map, data)

@callback load(
  schema_or_map :: module() | map(),
  data :: map() | keyword() | {list(), list()}
) ::
  Skuld.Comp.Types.computation(struct() | map())

one(queryable)

@callback one(queryable :: Ecto.Queryable.t()) ::
  Skuld.Comp.Types.computation(struct() | nil)

one(queryable, opts)

@callback one(queryable :: Ecto.Queryable.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct() | nil)

one!(queryable)

@callback one!(queryable :: Ecto.Queryable.t()) :: Skuld.Comp.Types.computation(struct())

one!(queryable, opts)

@callback one!(queryable :: Ecto.Queryable.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct())

preload(structs_or_struct_or_nil, preloads)

@callback preload(
  structs_or_struct_or_nil :: [struct()] | struct() | nil,
  preloads :: term()
) ::
  Skuld.Comp.Types.computation([struct()] | struct() | nil)

preload(structs_or_struct_or_nil, preloads, opts)

@callback preload(
  structs_or_struct_or_nil :: [struct()] | struct() | nil,
  preloads :: term(),
  opts :: keyword()
) :: Skuld.Comp.Types.computation([struct()] | struct() | nil)

query(sql)

@callback query(sql :: String.t()) ::
  Skuld.Comp.Types.computation({:ok, term()} | {:error, term()})

query(sql, params)

@callback query(sql :: String.t(), params :: list()) ::
  Skuld.Comp.Types.computation({:ok, term()} | {:error, term()})

query(sql, params, opts)

@callback query(sql :: String.t(), params :: list(), opts :: keyword()) ::
  Skuld.Comp.Types.computation({:ok, term()} | {:error, term()})

query!(sql)

@callback query!(sql :: String.t()) :: Skuld.Comp.Types.computation(term())

query!(sql, params)

@callback query!(sql :: String.t(), params :: list()) ::
  Skuld.Comp.Types.computation(term())

query!(sql, params, opts)

@callback query!(sql :: String.t(), params :: list(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(term())

reload(struct_or_structs)

@callback reload(struct_or_structs :: struct() | [struct()]) ::
  Skuld.Comp.Types.computation(struct() | nil | [struct() | nil])

reload(struct_or_structs, opts)

@callback reload(struct_or_structs :: struct() | [struct()], opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct() | nil | [struct() | nil])

reload!(struct_or_structs)

@callback reload!(struct_or_structs :: struct() | [struct()]) ::
  Skuld.Comp.Types.computation(struct() | [struct()])

reload!(struct_or_structs, opts)

@callback reload!(struct_or_structs :: struct() | [struct()], opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct() | [struct()])

stream(queryable)

@callback stream(queryable :: Ecto.Queryable.t()) ::
  Skuld.Comp.Types.computation(Enum.t())

stream(queryable, opts)

@callback stream(queryable :: Ecto.Queryable.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(Enum.t())

update(changeset)

@callback update(changeset :: Ecto.Changeset.t()) ::
  Skuld.Comp.Types.computation({:ok, struct()} | {:error, Ecto.Changeset.t()})

update(changeset, opts)

@callback update(changeset :: Ecto.Changeset.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation({:ok, struct()} | {:error, Ecto.Changeset.t()})

update!(changeset)

@callback update!(changeset :: Ecto.Changeset.t()) ::
  Skuld.Comp.Types.computation(struct())

update!(changeset, opts)

@callback update!(changeset :: Ecto.Changeset.t(), opts :: keyword()) ::
  Skuld.Comp.Types.computation(struct())

update_all(queryable, updates, opts)

@callback update_all(
  queryable :: Ecto.Queryable.t(),
  updates :: keyword(),
  opts :: keyword()
) ::
  Skuld.Comp.Types.computation({non_neg_integer(), nil | list()})