TLDR; Is this a good way to writing context functions? Especially when preloads are nested, or for some other reason there is some complexity. If not, what is the way to go?
I was reading the topic Preloading, some of the time, all of the time, none of the time? from some years ago. In the topic a number of different approaches to implementing context functions are mentioned. It also covers when to preload and why, as the title of the referenced topic suggests.
I rewrote a get_post/2 function of mine, because after have read the mentioned topic, among others, I felt it needed improvement.
How close is this to what could be considered good practice? Am I missing something still? For example, will this approach bite me later on, when requirements shift?
One thing I noticed myself is that my context module now has a lot more private functions in it than before. Those distract a bit from the top level functions that are actually the ones that I would call from the web layer. Do you put these private functions somewhere else? For example, under the post schema in Post.ex?
Quick background: A post has many post replies. And a post reply has many post subreplies. The post and post reply schema’s each have a virtual field for the (sub)reply count.
@doc """
Returns the post with the given `id`.
## Options
* `:preload_user` - preload the user association of the post, its replies, and its subreplies (:all), or a keyword list of fields to select from the user table
* `:preload_replies` - a boolean indicating whether to preload the replies association (default: false)
* `:preload_subreplies` - a boolean indicating whether to preload the subreplies association (default: false)
* `:with_reply_count` - a boolean indicating whether to preload `:reply_count` and `:subreply_count` virtual fields (default: false)
## Example
%Post{} = Posts.get_post(
post_id,
preload_user: [:id, :avatar, :username],
preload_replies: true,
preload_subreplies: true,
with_reply_count: true
)
"""
def get_post(id, opts \\ []) do
from(p in Post, where: p.id == ^id)
|> add_reply_count(opts)
|> preload_user(opts)
|> preload_replies(opts)
|> preload_subreplies(opts)
|> Repo.one()
end
defp add_reply_count(query, opts) do
case Keyword.get(opts, :with_reply_count, false) do
true ->
from post in query,
left_join: reply in assoc(post, :replies),
left_join: subreply in assoc(reply, :subreplies),
group_by: [post.id],
select_merge: %{reply_count: count(reply.id, :distinct) + count(subreply.id)}
_ ->
query
end
end
defp preload_user(query, opts) do
preload_user = Keyword.get(opts, :preload_user)
case preload_user do
:all ->
from q in query,
preload: [:user]
nil ->
query
fields ->
user_query =
from u in User,
select: ^fields
from q in query,
preload: [user: ^user_query]
end
end
defp preload_replies(query, opts) do
case Keyword.get(opts, :preload_replies) do
true ->
replies_query =
from(PostReply)
|> sort_by_inserted_at()
|> add_subreply_count(opts)
|> preload_user(opts)
from post in query,
preload: [replies: ^replies_query]
_ ->
query
end
end
defp sort_by_inserted_at(query) do
from q in query,
order_by: [asc: q.inserted_at]
end
defp add_subreply_count(query, opts) do
case Keyword.get(opts, :with_reply_count, false) do
true ->
from reply in query,
left_join: subreply in assoc(reply, :subreplies),
group_by: [reply.id],
select_merge: %{subreply_count: count(subreply.id)}
_ ->
query
end
end
defp preload_subreplies(query, opts) do
case Keyword.get(opts, :preload_subreplies) do
true ->
subreplies_query =
from(PostSubreply)
|> sort_by_inserted_at()
|> preload_user(opts)
from subreply in query,
preload: [replies: [subreplies: ^subreplies_query]]
_ ->
query
end
end
