Phoenix Context connection struct best practice

I would love to hear other opinions on this, but I think the key thing here would be that the contexts do not specifically know about %Plug.Conn.

You definitely don’t want this context function signature…

def create(%Plug.Conn{} = conn)

You could be less specific about it and grab things out of a struct that just happens to have the same structure as a conn if it really makes sense for your context API, but it almost surely does not…

def create(%{assigns: %{organization: organization, user: user, token: token}})

However, this is coupled to the structure of a conn and doesn’t seem like clean arguments for the context function.

You could pass just the assigns so as not to reach deeply into the struct…

def create(%{organization: organization, user: user, token: token})

But you are still reliant on how the conn is built up on the web side of your app and it is still arguable whether this is a clean way to take arguments in the context function.

Try to imagine you didn’t have a web interface for your app at all and were only designing the context function. How would you want the function signature to operate? Let that dictate what/how arguments are passed in.

For instance, maybe a function signature like this makes more sense in your app…

def create(%Organization{} = organization, %User{} = user, token})

This should be more resistant to breakage due to changes in the controller because you will have been explicit of the needs of the function at the boundaries.

I also avoid passing Web conn to the core.You might want to change for a Text interface later…

Plugs and controllers are specifically there to convert the input (being the http request) to input for functions on contexts (now no longer a http construct, but elixir values). Just like a CLI would convert argv input (usually just string values) to elixir values before querying the contexts.

Really depends what you are after but in any case I am with @baldwindavid that you shouldn’t leak Plug.Conn to your contexts. If you need parts of your assigns / session / private conn attributes then just pass them to your context functions. I’d even advise you to trim absolutely everything from them that you don’t need directly.

If you only need :cart_id and :user_id for a given context function then I’d do this:

defmodule MyApp.WhateverController do
  def index(conn, params) do
   conn.assigns
   |> Enum.take([:cart_id, :user_id]) # Only take the pieces of info your context function needs.
   |> MyApp.Orders.do_something_with_cart_and_user() # Pipe them to the context function. 
  end
end

As an example pseudo-code.

Absolutely don’t rely on implementation details. Now you have a Plug.Conn but later you might work with Absinthe (for GraphQL endpoints) and who knows what else.

Thank you for the great explanation!