Move preloading to API controllers (#43)

Author: dhrdlicka

lib/swapi/films.ex

@@ -22,28 +22,26 @@ defmodule SWAPI.Films do
       [%Film{}, ...]
 
   """
-  def list_films do
-    Film
-    |> Repo.all()
-    |> preload_all()
-  end
+  def list_films, do: Repo.all(Film)
 
-  def list_films(params) do
-    with {:ok, {films, meta}} <- paginate(Film, params) do
-      {:ok, {preload_all(films), meta}}
-    end
+  def list_films(params), do: paginate(Film, params)
+
+  def search_films(terms) do
+    terms
+    |> Enum.reduce(Film, fn term, query ->
+      query
+      |> where([f], like(f.title, ^"%#{term}%"))
+    end)
+    |> Repo.all()
   end
 
   def search_films(terms, params) do
-    films =
-      Enum.reduce(terms, Film, fn term, query ->
-        query
-        |> where([f], like(f.title, ^"%#{term}%"))
-      end)
-
-    with {:ok, {films, meta}} <- paginate(films, params) do
-      {:ok, {preload_all(films), meta}}
-    end
+    terms
+    |> Enum.reduce(Film, fn term, query ->
+      query
+      |> where([f], like(f.title, ^"%#{term}%"))
+    end)
+    |> paginate(params)
   end
 
   @doc """
@@ -60,16 +58,12 @@ defmodule SWAPI.Films do
       ** (Ecto.NoResultsError)
 
   """
-  def get_film!(id) do
-    Film
-    |> Repo.get!(id)
-    |> preload_all()
-  end
+  def get_film!(id), do: Repo.get!(Film, id)
 
   def get_film(id) do
     case Repo.get(Film, id) do
       %Film{} = film ->
-        {:ok, preload_all(film)}
+        {:ok, film}
 
       _ ->
         {:error, :not_found}

lib/swapi/people.ex

@@ -22,28 +22,26 @@ defmodule SWAPI.People do
       [%Person{}, ...]
 
   """
-  def list_people do
-    Person
-    |> Repo.all()
-    |> preload_all()
-  end
+  def list_people, do: Repo.all(Person)
 
-  def list_people(params) do
-    with {:ok, {people, meta}} <- paginate(Person, params) do
-      {:ok, {preload_all(people), meta}}
-    end
+  def list_people(params), do: paginate(Person, params)
+
+  def search_people(terms) do
+    terms
+    |> Enum.reduce(Person, fn term, query ->
+      query
+      |> where([p], like(p.name, ^"%#{term}%"))
+    end)
+    |> Repo.all()
   end
 
   def search_people(terms, params) do
-    people =
-      Enum.reduce(terms, Person, fn term, query ->
-        query
-        |> where([p], like(p.name, ^"%#{term}%"))
-      end)
-
-    with {:ok, {people, meta}} <- paginate(people, params) do
-      {:ok, {preload_all(people), meta}}
-    end
+    terms
+    |> Enum.reduce(Person, fn term, query ->
+      query
+      |> where([p], like(p.name, ^"%#{term}%"))
+    end)
+    |> paginate(params)
   end
 
   @doc """
@@ -60,16 +58,12 @@ defmodule SWAPI.People do
       ** (Ecto.NoResultsError)
 
   """
-  def get_person!(id) do
-    Person
-    |> Repo.get!(id)
-    |> preload_all()
-  end
+  def get_person!(id), do: Repo.get!(Person, id)
 
   def get_person(id) do
     case Repo.get(Person, id) do
       %Person{} = person ->
-        {:ok, preload_all(person)}
+        {:ok, person}
 
       _ ->
         {:error, :not_found}

lib/swapi/planets.ex

@@ -22,28 +22,26 @@ defmodule SWAPI.Planets do
       [%Planet{}, ...]
 
   """
-  def list_planets do
-    Planet
-    |> Repo.all()
-    |> preload_all()
-  end
+  def list_planets, do: Repo.all(Planet)
 
-  def list_planets(params) do
-    with {:ok, {planets, meta}} <- paginate(Planet, params) do
-      {:ok, {preload_all(planets), meta}}
-    end
+  def list_planets(params), do: paginate(Planet, params)
+
+  def search_planets(terms) do
+    terms
+    |> Enum.reduce(Planet, fn term, query ->
+      query
+      |> where([p], like(p.name, ^"%#{term}%"))
+    end)
+    |> Repo.all()
   end
 
   def search_planets(terms, params) do
-    planets =
-      Enum.reduce(terms, Planet, fn term, query ->
-        query
-        |> where([p], like(p.name, ^"%#{term}%"))
-      end)
-
-    with {:ok, {planets, meta}} <- paginate(planets, params) do
-      {:ok, {preload_all(planets), meta}}
-    end
+    terms
+    |> Enum.reduce(Planet, fn term, query ->
+      query
+      |> where([p], like(p.name, ^"%#{term}%"))
+    end)
+    |> paginate(params)
   end
 
   @doc """
@@ -60,16 +58,12 @@ defmodule SWAPI.Planets do
       ** (Ecto.NoResultsError)
 
   """
-  def get_planet!(id) do
-    Planet
-    |> Repo.get!(id)
-    |> preload_all()
-  end
+  def get_planet!(id), do: Repo.get!(Planet, id)
 
   def get_planet(id) do
     case Repo.get(Planet, id) do
       %Planet{} = planet ->
-        {:ok, preload_all(planet)}
+        {:ok, planet}
 
       _ ->
         {:error, :not_found}

lib/swapi/species.ex

@@ -22,28 +22,26 @@ defmodule SWAPI.Species do
       [%Species{}, ...]
 
   """
-  def list_species do
-    Species
-    |> Repo.all()
-    |> preload_all()
-  end
+  def list_species, do: Repo.all(Species)
 
-  def list_species(params) do
-    with {:ok, {species, meta}} <- paginate(Species, params) do
-      {:ok, {preload_all(species), meta}}
-    end
+  def list_species(params), do: paginate(Species, params)
+
+  def search_species(terms) do
+    terms
+    |> Enum.reduce(Species, fn term, query ->
+      query
+      |> where([s], like(s.name, ^"%#{term}%"))
+    end)
+    |> Repo.all()
   end
 
   def search_species(terms, params) do
-    species =
-      Enum.reduce(terms, Species, fn term, query ->
-        query
-        |> where([s], like(s.name, ^"%#{term}%"))
-      end)
-
-    with {:ok, {species, meta}} <- paginate(species, params) do
-      {:ok, {preload_all(species), meta}}
-    end
+    terms
+    |> Enum.reduce(Species, fn term, query ->
+      query
+      |> where([s], like(s.name, ^"%#{term}%"))
+    end)
+    |> paginate(params)
   end
 
   @doc """
@@ -60,16 +58,12 @@ defmodule SWAPI.Species do
       ** (Ecto.NoResultsError)
 
   """
-  def get_species!(id) do
-    Species
-    |> Repo.get!(id)
-    |> preload_all()
-  end
+  def get_species!(id), do: Repo.get!(Species, id)
 
   def get_species(id) do
     case Repo.get(Species, id) do
       %Species{} = species ->
-        {:ok, preload_all(species)}
+        {:ok, species}
 
       _ ->
         {:error, :not_found}

lib/swapi/starships.ex

@@ -23,32 +23,34 @@ defmodule SWAPI.Starships do
       [%Starship{}, ...]
 
   """
-  def list_starships do
-    Starship
-    |> Repo.all()
-    |> preload_all()
-  end
+  def list_starships, do: Repo.all(Starship)
 
-  def list_starships(params) do
-    with {:ok, {starships, meta}} <- paginate(Starship, params) do
-      {:ok, {preload_all(starships), meta}}
-    end
+  def list_starships(params), do: paginate(Starship, params)
+
+  def search_starships(terms) do
+    query =
+      Starship
+      |> join(:left, [s], t in Transport, on: s.id == t.id)
+
+    terms
+    |> Enum.reduce(query, fn term, query ->
+      query
+      |> where([s, t], like(t.name, ^"%#{term}%") or like(t.model, ^"%#{term}%"))
+    end)
+    |> Repo.all()
   end
 
   def search_starships(terms, params) do
     query =
       Starship
       |> join(:left, [s], t in Transport, on: s.id == t.id)
 
-    starships =
-      Enum.reduce(terms, query, fn term, query ->
-        query
-        |> where([s, t], like(t.name, ^"%#{term}%") or like(t.model, ^"%#{term}%"))
-      end)
-
-    with {:ok, {starships, meta}} <- paginate(starships, params) do
-      {:ok, {preload_all(starships), meta}}
-    end
+    terms
+    |> Enum.reduce(query, fn term, query ->
+      query
+      |> where([s, t], like(t.name, ^"%#{term}%") or like(t.model, ^"%#{term}%"))
+    end)
+    |> paginate(params)
   end
 
   @doc """
@@ -65,16 +67,12 @@ defmodule SWAPI.Starships do
       ** (Ecto.NoResultsError)
 
   """
-  def get_starship!(id) do
-    Starship
-    |> Repo.get!(id)
-    |> preload_all()
-  end
+  def get_starship!(id), do: Repo.get!(Starship, id)
 
   def get_starship(id) do
     case Repo.get(Starship, id) do
       %Starship{} = starship ->
-        {:ok, preload_all(starship)}
+        {:ok, starship}
 
       _ ->
         {:error, :not_found}

lib/swapi/vehicles.ex

@@ -23,32 +23,34 @@ defmodule SWAPI.Vehicles do
       [%Vehicle{}, ...]
 
   """
-  def list_vehicles do
-    Vehicle
-    |> Repo.all()
-    |> preload_all()
-  end
+  def list_vehicles, do: Repo.all(Vehicle)
 
-  def list_vehicles(params) do
-    with {:ok, {vehicles, meta}} <- paginate(Vehicle, params) do
-      {:ok, {preload_all(vehicles), meta}}
-    end
+  def list_vehicles(params), do: paginate(Vehicle, params)
+
+  def search_vehicles(terms) do
+    query =
+      Vehicle
+      |> join(:left, [v], t in Transport, on: v.id == t.id)
+
+    terms
+    |> Enum.reduce(query, fn term, query ->
+      query
+      |> where([v, t], like(t.name, ^"%#{term}%") or like(t.model, ^"%#{term}%"))
+    end)
+    |> Repo.all()
   end
 
   def search_vehicles(terms, params) do
     query =
       Vehicle
       |> join(:left, [v], t in Transport, on: v.id == t.id)
 
-    vehicles =
-      Enum.reduce(terms, query, fn term, query ->
-        query
-        |> where([v, t], like(t.name, ^"%#{term}%") or like(t.model, ^"%#{term}%"))
-      end)
-
-    with {:ok, {vehicles, meta}} <- paginate(vehicles, params) do
-      {:ok, {preload_all(vehicles), meta}}
-    end
+    terms
+    |> Enum.reduce(query, fn term, query ->
+      query
+      |> where([v, t], like(t.name, ^"%#{term}%") or like(t.model, ^"%#{term}%"))
+    end)
+    |> paginate(params)
   end
 
   @doc """
@@ -65,16 +67,12 @@ defmodule SWAPI.Vehicles do
       ** (Ecto.NoResultsError)
 
   """
-  def get_vehicle!(id) do
-    Vehicle
-    |> Repo.get!(id)
-    |> preload_all()
-  end
+  def get_vehicle!(id), do: Repo.get!(Vehicle, id)
 
   def get_vehicle(id) do
     case Repo.get(Vehicle, id) do
       %Vehicle{} = vehicle ->
-        {:ok, preload_all(vehicle)}
+        {:ok, vehicle}
 
       _ ->
         {:error, :not_found}