Rewrite LastFm.APIImpl using Req

lib/last_fm/api_impl.ex

@@ -5,164 +5,171 @@ defmodule LastFm.APIImpl do
 
   alias LastFm.{Artist, Track}
 
-  @base_url "https://ws.audioscrobbler.com/2.0/"
+  defmodule ErrorResponse do
+    defstruct [:error, :message]
 
-  # Experimental: metrics show some long running requests
+    def new(error_code, message) do
-  # that end up hitting timeouts (at default values),
+      %__MODULE__{error: map_error(error_code), message: message}
-  # so we make them shorter to leverage retries
+    end
-  @request_opts [
+
-    pool_timeout: 1000,
+    defp map_error(2), do: :invalid_service
-    receive_timeout: 1000,
+    defp map_error(3), do: :invalid_method
-    request_timeout: 2500
+    defp map_error(4), do: :authentication_failed
-  ]
+    defp map_error(5), do: :invalid_format
+    defp map_error(6), do: :invalid_parameters
+    defp map_error(7), do: :invalid_resource
+    defp map_error(8), do: :operation_failed
+    defp map_error(9), do: :invalid_session_key
+    defp map_error(10), do: :invalid_api_key
+    defp map_error(11), do: :service_offline
+    defp map_error(13), do: :invalid_method_signature
+    defp map_error(16), do: :transient_error
+    defp map_error(26), do: :suspended_api_key
+    defp map_error(29), do: :rate_limit_exceeded
+  end
 
   @impl true
   def get_recent_tracks(config) do
-    options = [
+    params =
-      method: "user.getrecenttracks",
+      config
-      user: config.user,
+      |> base_params()
-      api_key: config.api_key,
+      |> Keyword.merge(method: "user.getrecenttracks", limit: 50)
-      format: "json",
-      limit: 50
-    ]
 
-    url = @base_url <> "?" <> URI.encode_query(options)
+    config
-
+    |> new_request()
-    Logger.debug("Fetching data from #{sanitize_url(url, config.api_key)}")
+    |> Req.merge(url: "/", params: params)
-
+    |> Req.Request.append_response_steps(parse_tracks: &parse_tracks/1)
-    case json_get(url, config.user_agent) do
+    |> get_request()
-      {:ok, response} ->
-        {:ok,
-         response
-         |> get_in(["recenttracks", "track"])
-         |> Track.from_api_response()}
-
-      other ->
-        msg =
-          "Failed to fetch data from #{sanitize_url(url, config.api_key)}, reason: #{inspect(other)}"
-
-        Logger.error(msg)
-        {:error, msg}
-    end
   end
 
   @impl true
-  def get_artist_info({:musicbrainz_id, artist_mbid}, config) do
+  def get_artist_info(id_or_name_option, config) do
-    do_get_artist_info([mbid: artist_mbid], config)
+    params =
-  end
+      config
+      |> base_params()
+      |> Keyword.merge(method: "artist.getInfo")
+      |> put_musicbrainz_id_or_name(id_or_name_option)
 
-  def get_artist_info({:name, artist_name}, config) do
+    config
-    do_get_artist_info([artist: artist_name], config)
+    |> new_request()
-  end
+    |> Req.merge(url: "/", params: params)
-
+    |> Req.Request.append_response_steps(parse_tracks: &parse_artist/1)
-  defp do_get_artist_info(options, config) do
+    |> get_request()
-    base_options = [
-      method: "artist.getInfo",
-      api_key: config.api_key,
-      user: config.user,
-      format: "json",
-      limit: 50
-    ]
-
-    options = Keyword.merge(base_options, options)
-
-    url = @base_url <> "?" <> URI.encode_query(options)
-
-    Logger.debug("Fetching data from #{sanitize_url(url, config.api_key)}")
-
-    case json_get(url, config.user_agent) do
-      {:ok, response} ->
-        {:ok,
-         response
-         |> Map.get("artist")
-         |> Artist.from_api_response()}
-
-      error ->
-        msg =
-          "Failed to fetch data from #{sanitize_url(url, config.api_key)}, reason: #{inspect(error)}"
-
-        Logger.error(msg)
-        error
-    end
   end
 
   @impl true
-  def get_similar_artists({:name, artist_name}, config) do
+  def get_similar_artists(id_or_name_option, config) do
-    do_get_similar_artists([artist: artist_name], config)
+    params =
+      config
+      |> base_params()
+      |> Keyword.merge(limit: 100, method: "artist.getSimilar")
+      |> put_musicbrainz_id_or_name(id_or_name_option)
+
+    config
+    |> new_request()
+    |> Req.merge(url: "/", params: params)
+    |> Req.Request.append_response_steps(parse_tracks: &parse_similar_artists/1)
+    |> get_request()
   end
 
-  def get_similar_artists({:musicbrainz_id, artist_mbid}, config) do
+  defp put_musicbrainz_id_or_name(params, {:musicbrainz_id, musicbrainz_id}) do
-    do_get_similar_artists([mbid: artist_mbid], config)
+    Keyword.put(params, :mbid, musicbrainz_id)
   end
 
-  defp do_get_similar_artists(options, config) do
+  defp put_musicbrainz_id_or_name(params, {:name, name}) do
-    base_options = [
+    Keyword.put(params, :artist, name)
-      method: "artist.getSimilar",
+  end
+
+  defp base_params(config) do
+    [
+      user: config.user,
       api_key: config.api_key,
-      format: "json",
+      format: "json"
-      limit: 100
     ]
+  end
 
-    options = Keyword.merge(base_options, options)
+  defp new_request(config) do
+    Req.new(
+      base_url: "https://ws.audioscrobbler.com/2.0/",
+      # Experimental: metrics show some long running requests
+      # that end up hitting timeouts (at default values),
+      # so we make them shorter to leverage retries
+      max_retries: 1,
+      pool_timeout: 1000,
+      receive_timeout: 1000,
+      connect_options: [
+        timeout: 2500
+      ],
+      user_agent: config.user_agent
+    )
+    |> Req.Request.put_private(:api_key, config.api_key)
+    |> Req.Request.append_request_steps(log_attempt: &log_attempt/1)
+    |> Req.Request.append_response_steps(parse_error: &parse_error/1)
+  end
 
-    url = @base_url <> "?" <> URI.encode_query(options)
+  defp get_request(request) do
+    case Req.get(request) do
+      {:ok, %{body: %ErrorResponse{} = error_response}} ->
+        {:error, error_response.error}
 
-    Logger.debug("Fetching data from #{sanitize_url(url, config.api_key)}")
-
-    case json_get(url, config.user_agent) do
       {:ok, response} ->
-        {:ok,
+        {:ok, response.body}
-         response
-         |> get_in(["similarartists", "artist"])
-         |> Enum.map(&Artist.from_api_response/1)}
-
-      error ->
-        msg =
-          "Failed to fetch data from #{sanitize_url(url, config.api_key)}, reason: #{inspect(error)}"
-
-        Logger.error(msg)
-        error
     end
   end
 
-  defp json_get(url, user_agent) do
+  defp log_attempt(request) do
-    req =
+    url = URI.to_string(request.url)
-      Finch.build(:get, url, [
+    api_key = Req.Request.get_private(request, :api_key)
-        {"User-Agent", user_agent}
+    Logger.debug("Fetching data from #{sanitize_url(url, api_key)}")
-      ])
+    request
+  end
 
-    case Finch.request(req, LastFm.Finch, @request_opts) do
+  defp parse_error({request, response}) do
-      {:ok, response} when response.status == 200 ->
+    case response.body do
-        JSON.decode(response.body)
+      %{"error" => error_number, "message" => message} ->
-        |> identify_body()
+        error = ErrorResponse.new(error_number, message)
 
-      other ->
+        Logger.error(fn ->
-        other
+          url = URI.to_string(request.url)
+          api_key = Req.Request.get_private(request, :api_key)
+          "Failed to fetch data from #{sanitize_url(url, api_key)}, reason: #{message}."
+        end)
+
+        Req.Request.halt(request, Map.put(response, :body, error))
+
+      _other ->
+        {request, response}
     end
   end
 
+  defp parse_tracks({request, response}) do
+    tracks =
+      response.body
+      |> get_in(["recenttracks", "track"])
+      |> Track.from_api_response()
+
+    {request, Map.put(response, :body, tracks)}
+  end
+
+  defp parse_artist({request, response}) do
+    artist =
+      response.body
+      |> Map.get("artist")
+      |> Artist.from_api_response()
+
+    {request, Map.put(response, :body, artist)}
+  end
+
+  defp parse_similar_artists({request, response}) do
+    artists =
+      response.body
+      |> get_in(["similarartists", "artist"])
+      |> Enum.map(&Artist.from_api_response/1)
+
+    {request, Map.put(response, :body, artists)}
+  end
+
   defp sanitize_url(url, api_key) do
     String.replace(url, api_key, "<redacted_api_key>")
   end
-
-  defp identify_body({:ok, %{"error" => error_number, "message" => _message}}) do
-    {:error, map_error(error_number)}
-  end
-
-  defp identify_body(other), do: other
-
-  defp map_error(2), do: :invalid_service
-  defp map_error(3), do: :invalid_method
-  defp map_error(4), do: :authentication_failed
-  defp map_error(5), do: :invalid_format
-  defp map_error(6), do: :invalid_parameters
-  defp map_error(7), do: :invalid_resource
-  defp map_error(8), do: :operation_failed
-  defp map_error(9), do: :invalid_session_key
-  defp map_error(10), do: :invalid_api_key
-  defp map_error(11), do: :service_offline
-  defp map_error(13), do: :invalid_method_signature
-  defp map_error(16), do: :transient_error
-  defp map_error(26), do: :suspended_api_key
-  defp map_error(29), do: :rate_limit_exceeded
 end