Add GraphQL endpoint

.formatter.exs

@@ -1,6 +1,11 @@
 [
   import_deps: [:ecto, :ecto_sql, :phoenix],
   subdirectories: ["priv/*/migrations"],
-  plugins: [Phoenix.LiveView.HTMLFormatter],
-  inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}", "priv/*/seeds.exs"]
+  plugins: [Phoenix.LiveView.HTMLFormatter, Absinthe.Formatter],
+  inputs: [
+    "*.{ex,exs}",
+    "{config,lib,test}/**/*.{ex,exs}",
+    "priv/*/seeds.exs",
+    "{lib,priv}/**/*.{gql,graphql}"
+  ]
 ]

lib/swapi/dataloader.ex

@@ -0,0 +1,9 @@
+defmodule SWAPI.Dataloader do
+  @moduledoc """
+  Dataloader for GraphQL
+  """
+
+  def data, do: Dataloader.Ecto.new(SWAPI.Repo, query: &query/2)
+
+  def query(queryable, _params), do: queryable
+end

lib/swapi_web/graphql/queries.ex

@@ -0,0 +1,23 @@
+defmodule SWAPIWeb.GraphQL.Queries do
+  @moduledoc """
+  GraphQL queries
+  """
+
+  use Absinthe.Schema.Notation
+
+  import_types(SWAPIWeb.GraphQL.Queries.FilmQueries)
+  import_types(SWAPIWeb.GraphQL.Queries.PersonQueries)
+  import_types(SWAPIWeb.GraphQL.Queries.PlanetQueries)
+  import_types(SWAPIWeb.GraphQL.Queries.SpeciesQueries)
+  import_types(SWAPIWeb.GraphQL.Queries.StarshipQueries)
+  import_types(SWAPIWeb.GraphQL.Queries.VehicleQueries)
+
+  object :queries do
+    import_fields(:film_queries)
+    import_fields(:person_queries)
+    import_fields(:planet_queries)
+    import_fields(:species_queries)
+    import_fields(:starship_queries)
+    import_fields(:vehicle_queries)
+  end
+end

lib/swapi_web/graphql/queries/film_queries.ex

@@ -0,0 +1,32 @@
+defmodule SWAPIWeb.GraphQL.Queries.FilmQueries do
+  @moduledoc """
+  GraphQL queries for films
+  """
+
+  use Absinthe.Schema.Notation
+
+  alias SWAPIWeb.GraphQL.Resolvers.FilmResolver
+
+  object :film_queries do
+    @desc "Get all films."
+    field :all_films, list_of(:film) do
+      resolve(&FilmResolver.all/2)
+    end
+
+    @desc "Get a film by ID."
+    field :film, :film do
+      @desc "The ID of the film."
+      arg(:id, non_null(:id))
+
+      resolve(&FilmResolver.one/2)
+    end
+
+    @desc "Search films by title."
+    field :search_films, list_of(:film) do
+      @desc "A list of search terms. If multiple search terms are used then objects will be returned in the list only if all the provided terms are matched."
+      arg(:search_terms, non_null(list_of(non_null(:string))))
+
+      resolve(&FilmResolver.search/2)
+    end
+  end
+end

lib/swapi_web/graphql/queries/person_queries.ex

@@ -0,0 +1,32 @@
+defmodule SWAPIWeb.GraphQL.Queries.PersonQueries do
+  @moduledoc """
+  GraphQL queries for people
+  """
+
+  use Absinthe.Schema.Notation
+
+  alias SWAPIWeb.GraphQL.Resolvers.PersonResolver
+
+  object :person_queries do
+    @desc "Get all people."
+    field :all_people, list_of(:person) do
+      resolve(&PersonResolver.all/2)
+    end
+
+    @desc "Get a person by ID."
+    field :person, :person do
+      @desc "The ID of the person."
+      arg(:id, non_null(:id))
+
+      resolve(&PersonResolver.one/2)
+    end
+
+    @desc "Search people by name."
+    field :search_people, list_of(:person) do
+      @desc "A list of search terms. If multiple search terms are used then objects will be returned in the list only if all the provided terms are matched."
+      arg(:search_terms, non_null(list_of(non_null(:string))))
+
+      resolve(&PersonResolver.search/2)
+    end
+  end
+end

lib/swapi_web/graphql/queries/planet_queries.ex

@@ -0,0 +1,32 @@
+defmodule SWAPIWeb.GraphQL.Queries.PlanetQueries do
+  @moduledoc """
+  GraphQL queries for planets
+  """
+
+  use Absinthe.Schema.Notation
+
+  alias SWAPIWeb.GraphQL.Resolvers.PlanetResolver
+
+  object :planet_queries do
+    @desc "Get all planets."
+    field :all_planets, list_of(:planet) do
+      resolve(&PlanetResolver.all/2)
+    end
+
+    @desc "Get a planet by ID."
+    field :planet, :planet do
+      @desc "The ID of the planet."
+      arg(:id, non_null(:id))
+
+      resolve(&PlanetResolver.one/2)
+    end
+
+    @desc "Search planets by name."
+    field :search_planets, list_of(:planet) do
+      @desc "A list of search terms. If multiple search terms are used then objects will be returned in the list only if all the provided terms are matched."
+      arg(:search_terms, non_null(list_of(non_null(:string))))
+
+      resolve(&PlanetResolver.search/2)
+    end
+  end
+end

lib/swapi_web/graphql/queries/species_queries.ex

@@ -0,0 +1,32 @@
+defmodule SWAPIWeb.GraphQL.Queries.SpeciesQueries do
+  @moduledoc """
+  GraphQL queries for species
+  """
+
+  use Absinthe.Schema.Notation
+
+  alias SWAPIWeb.GraphQL.Resolvers.SpeciesResolver
+
+  object :species_queries do
+    @desc "Get all species."
+    field :all_species, list_of(:species) do
+      resolve(&SpeciesResolver.all/2)
+    end
+
+    @desc "Get a species by ID."
+    field :species, :species do
+      @desc "The ID of the species."
+      arg(:id, non_null(:id))
+
+      resolve(&SpeciesResolver.one/2)
+    end
+
+    @desc "Search species by name."
+    field :search_species, list_of(:species) do
+      @desc "A list of search terms. If multiple search terms are used then objects will be returned in the list only if all the provided terms are matched."
+      arg(:search_terms, non_null(list_of(non_null(:string))))
+
+      resolve(&SpeciesResolver.search/2)
+    end
+  end
+end

lib/swapi_web/graphql/queries/starship_queries.ex

@@ -0,0 +1,32 @@
+defmodule SWAPIWeb.GraphQL.Queries.StarshipQueries do
+  @moduledoc """
+  GraphQL queries for starships
+  """
+
+  use Absinthe.Schema.Notation
+
+  alias SWAPIWeb.GraphQL.Resolvers.StarshipResolver
+
+  object :starship_queries do
+    @desc "Get all starships."
+    field :all_starships, list_of(:starship) do
+      resolve(&StarshipResolver.all/2)
+    end
+
+    @desc "Get a starship by ID."
+    field :starship, :starship do
+      @desc "The ID of the starship."
+      arg(:id, non_null(:id))
+
+      resolve(&StarshipResolver.one/2)
+    end
+
+    @desc "Search starships by name or model."
+    field :search_starships, list_of(:starship) do
+      @desc "A list of search terms. If multiple search terms are used then objects will be returned in the list only if all the provided terms are matched."
+      arg(:search_terms, non_null(list_of(non_null(:string))))
+
+      resolve(&StarshipResolver.search/2)
+    end
+  end
+end

lib/swapi_web/graphql/queries/vehicle_queries.ex

@@ -0,0 +1,32 @@
+defmodule SWAPIWeb.GraphQL.Queries.VehicleQueries do
+  @moduledoc """
+  GraphQL queries for vehicles
+  """
+
+  use Absinthe.Schema.Notation
+
+  alias SWAPIWeb.GraphQL.Resolvers.VehicleResolver
+
+  object :vehicle_queries do
+    @desc "Get all vehicles."
+    field :all_vehicles, list_of(:vehicle) do
+      resolve(&VehicleResolver.all/2)
+    end
+
+    @desc "Get a vehicle by ID."
+    field :vehicle, :vehicle do
+      @desc "The ID of the vehicle."
+      arg(:id, non_null(:id))
+
+      resolve(&VehicleResolver.one/2)
+    end
+
+    @desc "Search vehicles by name or model."
+    field :search_vehicles, list_of(:vehicle) do
+      @desc "A list of search terms. If multiple search terms are used then objects will be returned in the list only if all the provided terms are matched."
+      arg(:search_terms, non_null(list_of(non_null(:string))))
+
+      resolve(&VehicleResolver.search/2)
+    end
+  end
+end

lib/swapi_web/graphql/resolvers/film_resolver.ex

@@ -0,0 +1,26 @@
+defmodule SWAPIWeb.GraphQL.Resolvers.FilmResolver do
+  @moduledoc """
+  Film resolver.
+  """
+
+  alias SWAPI.Films
+  alias SWAPI.Schemas.Film
+
+  @spec all(map, map) :: {:ok, list(Film.t())} | {:error, any}
+  def all(_args, _info) do
+    {:ok, Films.list_films()}
+  end
+
+  @spec one(map, Absinthe.Blueprint.t()) :: {:ok, Film.t()} | {:error, any}
+  def one(%{id: id}, _info) do
+    case Films.get_film(id) do
+      {:ok, film} -> {:ok, film}
+      {:error, :not_found} -> {:error, "Film not found"}
+    end
+  end
+
+  @spec search(map, Absinthe.Blueprint.t()) :: {:ok, list(Film.t())} | {:error, any}
+  def search(%{search_terms: search_terms}, _info) do
+    {:ok, Films.search_films(search_terms)}
+  end
+end

lib/swapi_web/graphql/resolvers/person_resolver.ex

@@ -0,0 +1,26 @@
+defmodule SWAPIWeb.GraphQL.Resolvers.PersonResolver do
+  @moduledoc """
+  Person resolver.
+  """
+
+  alias SWAPI.People
+  alias SWAPI.Schemas.Person
+
+  @spec all(map, map) :: {:ok, list(Person.t())} | {:error, any}
+  def all(_args, _info) do
+    {:ok, People.list_people()}
+  end
+
+  @spec one(map, Absinthe.Resolution.t()) :: {:ok, Person.t()} | {:error, any}
+  def one(%{id: id}, _info) do
+    case People.get_person(id) do
+      {:ok, person} -> {:ok, person}
+      {:error, :not_found} -> {:error, "Person not found"}
+    end
+  end
+
+  @spec search(map, Absinthe.Blueprint.t()) :: {:ok, list(Person.t())} | {:error, any}
+  def search(%{search_terms: search_terms}, _info) do
+    {:ok, People.search_people(search_terms)}
+  end
+end

lib/swapi_web/graphql/resolvers/planet_resolver.ex

@@ -0,0 +1,26 @@
+defmodule SWAPIWeb.GraphQL.Resolvers.PlanetResolver do
+  @moduledoc """
+  Planet resolver.
+  """
+
+  alias SWAPI.Planets
+  alias SWAPI.Schemas.Planet
+
+  @spec all(map, map) :: {:ok, list(Planet.t())} | {:error, any}
+  def all(_args, _info) do
+    {:ok, Planets.list_planets()}
+  end
+
+  @spec one(map, Absinthe.Resolution.t()) :: {:ok, Planet.t()} | {:error, any}
+  def one(%{id: id}, _info) do
+    case Planets.get_planet(id) do
+      {:ok, planet} -> {:ok, planet}
+      {:error, :not_found} -> {:error, "Planet not found"}
+    end
+  end
+
+  @spec search(map, Absinthe.Blueprint.t()) :: {:ok, list(Planet.t())} | {:error, any}
+  def search(%{search_terms: search_terms}, _info) do
+    {:ok, Planets.search_planets(search_terms)}
+  end
+end

lib/swapi_web/graphql/resolvers/species_resolver.ex

@@ -0,0 +1,26 @@
+defmodule SWAPIWeb.GraphQL.Resolvers.SpeciesResolver do
+  @moduledoc """
+  Species resolver.
+  """
+
+  alias SWAPI.Schemas.Species, as: SpeciesSchema
+  alias SWAPI.Species
+
+  @spec all(map, map) :: {:ok, list(SpeciesSchema.t())} | {:error, any}
+  def all(_args, _info) do
+    {:ok, Species.list_species()}
+  end
+
+  @spec one(map, Absinthe.Resolution.t()) :: {:ok, SpeciesSchema.t()} | {:error, any}
+  def one(%{id: id}, _info) do
+    case Species.get_species(id) do
+      {:ok, species} -> {:ok, species}
+      {:error, :not_found} -> {:error, "Species not found"}
+    end
+  end
+
+  @spec search(map, Absinthe.Blueprint.t()) :: {:ok, list(SpeciesSchema.t())} | {:error, any}
+  def search(%{search_terms: search_terms}, _info) do
+    {:ok, Species.search_species(search_terms)}
+  end
+end

lib/swapi_web/graphql/resolvers/starship_resolver.ex

@@ -0,0 +1,26 @@
+defmodule SWAPIWeb.GraphQL.Resolvers.StarshipResolver do
+  @moduledoc """
+  Starship resolver.
+  """
+
+  alias SWAPI.Schemas.Starship
+  alias SWAPI.Starships
+
+  @spec all(map, map) :: {:ok, list(Starship.t())} | {:error, any}
+  def all(_args, _info) do
+    {:ok, Starships.list_starships()}
+  end
+
+  @spec one(map, Absinthe.Resolution.t()) :: {:ok, Starship.t()} | {:error, any}
+  def one(%{id: id}, _info) do
+    case Starships.get_starship(id) do
+      {:ok, starship} -> {:ok, starship}
+      {:error, :not_found} -> {:error, "Starship not found"}
+    end
+  end
+
+  @spec search(map, Absinthe.Blueprint.t()) :: {:ok, list(Starship.t())} | {:error, any}
+  def search(%{search_terms: search_terms}, _info) do
+    {:ok, Starships.search_starships(search_terms)}
+  end
+end