Is it possible to set up a Phoenix application such that all controller actions are automatically wrapped with a transaction, that gets automatically rolled back in case of unrescued exceptions?
In ruby I used to do this like the following:
require 'activerecord'
class TransactionalRequests
def initialize(app)
@app = app
end
def call(env)
ActiveRecord::Base.transaction do
@app.call(env)
end
end
end
It is also possible to use Ecto Multi and it is possible to wrap multiple operations inside a transaction. As there is no callback, it is used to perform⊠multiple operations.
But Ecto is not Active Record, it uses the Repo pattern.
And controller actions usually call contexts functions.
def action(conn, _) do
args = [conn, conn.params]
with {_, response} <- Repo.transaction(fn -> apply(__MODULE__, action_name(conn), args) end) do
response
end
end
It would be a better pattern if your web layer simply called a âcontextâ function that wrapped both function calls in a transaction. Improves visibility of what is actually occuring instead of hiding it within a plug. Plus makes testing easier.
In that case, you should probably have a single (maybe a third) context that takes care of what these two functions do. Which again could wrap both of them in another Repo.transaction(fn -> ... end).
When working with MVP/BDD, controllers really can strive to only have the single responsibility of âbeing a traffic copâ: Doing some preliminary checking of input parameters (and things like âis the user logged in?â) and then redirecting to the appropriate context(s).
The main thing to watch out for now is that your controller actions need to avoid doing non-database IO. If you make requests to external services that take several hundred ms for example, your request will be hogging the database connection for that time while not really using it.