14 replies

Why there is no `Ash.Changeset.around_transaction`?

I was wondering why there is no

around_transaction

around_transaction

function in

Ash.Changeset

Ash.Changeset

. We already have a

around_action

around_action

option, but that one runs inside a transaction, meaning that I can't use it if I wan't to add something to the DB regardless if the action itself fails or not.

I know that there is a

before_transaction

before_transaction

and

after_transaction

after_transaction

, but depending on what I'm doing this would not work.

Just to give a more concrete example.

I'm planning to port this into a Ash change:

  def lock_and_transact(user, type, apply_function, update_function) do
    Mutex.under(SubscribeMutex, user.uuid, fn ->
      response =
        case create_transaction(user, type) do
          {:ok, _} ->
            {:ok, response} = apply_function.()
            
            response

          {:error, _} ->
            user = update_function(user)

            {:error, :unfinished_transaction, handle_error!(type, user)}
        end

      delete_transaction!(user, type)

      response
    end)
  end

  def lock_and_transact(user, type, apply_function, update_function) do
    Mutex.under(SubscribeMutex, user.uuid, fn ->
      response =
        case create_transaction(user, type) do
          {:ok, _} ->
            {:ok, response} = apply_function.()
            
            response

          {:error, _} ->
            user = update_function(user)

            {:error, :unfinished_transaction, handle_error!(type, user)}
        end

      delete_transaction!(user, type)

      response
    end)
  end

The idea in this function is that I will first use

Mutex

Mutex

to make sure that I always have only one code path reaching this code block at a time, after it, I create a transaction, which basically means that I have a

transaction

transaction

table and I store a row there for that

user

user

and

type

type

.

I then run the

apply_function

apply_function

, if that function doesn't return an error, it will call the

delete_transaction!

delete_transaction!

function that will remove the transaction and return the response, otherwise, it will just crash leaving the added transaction in the DB, this means that next time this code is called, it will fail to create a transaction and it will run the

update_function

update_function

instead.

If I just wanted to create the transaction row in the DB, I would be able to create two changes, one with

after_transaction

after_transaction

(to create the row) and one with

before_transaction

before_transaction

(to delete it), but that doesn't work with the

Mutex

Mutex

call, for the mutex I need something like

around_action

around_action

but for transactions.

Ash Framework•3y ago•

14 replies

Blibs

Why there is no `Ash.Changeset.around_transaction`?

I was wondering why there is no

around_transaction

around_transaction

function in

Ash.Changeset

Ash.Changeset

. We already have a

around_action

around_action

option, but that one runs inside a transaction, meaning that I can't use it if I wan't to add something to the DB regardless if the action itself fails or not.

I know that there is a

before_transaction

before_transaction

and

after_transaction

after_transaction

, but depending on what I'm doing this would not work.

Just to give a more concrete example.

I'm planning to port this into a Ash change:

  def lock_and_transact(user, type, apply_function, update_function) do
    Mutex.under(SubscribeMutex, user.uuid, fn ->
      response =
        case create_transaction(user, type) do
          {:ok, _} ->
            {:ok, response} = apply_function.()
            
            response

          {:error, _} ->
            user = update_function(user)

            {:error, :unfinished_transaction, handle_error!(type, user)}
        end

      delete_transaction!(user, type)

      response
    end)
  end

  def lock_and_transact(user, type, apply_function, update_function) do
    Mutex.under(SubscribeMutex, user.uuid, fn ->
      response =
        case create_transaction(user, type) do
          {:ok, _} ->
            {:ok, response} = apply_function.()
            
            response

          {:error, _} ->
            user = update_function(user)

            {:error, :unfinished_transaction, handle_error!(type, user)}
        end

      delete_transaction!(user, type)

      response
    end)
  end

The idea in this function is that I will first use

Mutex

Mutex

to make sure that I always have only one code path reaching this code block at a time, after it, I create a transaction, which basically means that I have a

transaction

transaction

table and I store a row there for that

user

user

and

type

type

.

I then run the

apply_function

apply_function

, if that function doesn't return an error, it will call the

delete_transaction!

delete_transaction!

update_function

update_function

instead.

If I just wanted to create the transaction row in the DB, I would be able to create two changes, one with

after_transaction

after_transaction

(to create the row) and one with

before_transaction

before_transaction

(to delete it), but that doesn't work with the

Mutex

Mutex

call, for the mutex I need something like

around_action

around_action

but for transactions.

Why there is no `Ash.Changeset.around_transaction`?

Why there is no `Ash.Changeset.around_transaction`?

Similar Threads

Similar Threads

Similar Threads