neuron

defmodule Neuron do
  alias Neuron.{Response, Connection, Config, Fragment}

  @moduledoc """
  Neuron is a GraphQL client for elixir.

  ## Usage

  ```elixir
  iex> Neuron.Config.set(url: "https://example.com/graph")

  iex> Neuron.query(\"""
      {
        films {
          title
        }
      }
      \""")

  # Response will be:
  {:ok, %Neuron.Response{body: %{"data" => {"films" => [%{"title" => "A New Hope"}]}}%, status_code: 200, headers: []}}

  # You can also run mutations
  iex> Neuron.query(\"""
      mutation createUser($name: String!) {
        createUser(name: $name) {
          id
          name
        }
      }
    \""",
    %{name: "uesteibar"}
    )

  """

  @doc """
  runs a query request to your graphql endpoint.

  ## Example

  ```elixir
  Neuron.query(\"""
    {
      films {
        count
      }
    }
  \""")
  ```

  You can pass variables for your query

  ## Example

  ```elixir
  Neuron.query(
  \"""
    mutation createUser($name: String!) {
      createUser(name: $name) {
        id
        name
      }
    }
  \""",
  %{name: "uesteibar"}
  )
  ```

  You can also overwrite parameters set on `Neuron.Config` by passing them as options.

  ## Example

  ```elixir
  Neuron.query(
  \"""
    mutation createUser($name: String!) {
      createUser(name: $name) {
        id
        name
      }
    }
  \""",
  %{name: "uesteibar"},
  url: "https://www.other.com/graphql"
  )
  ```
  """

  @spec query(query_string :: String.t(), variables :: Map.t(), options :: keyword()) ::
          Neuron.Response.t()
  def query(query_string, variables \\ %{}, options \\ []) do
    query_string
    |> Fragment.insert_into_query()
    |> build_body()
    |> insert_variables(variables)
    |> Poison.encode!()
    |> run(options)
  end

  defp run(body, options) do
    body
    |> run_query(options)
    |> Response.handle()
  end

  defp run_query(body, options) do
    url = url(options)
    headers = build_headers(options)
    Connection.post(url, body, headers)
  end

  defp build_body(query_string), do: %{query: query_string}

  defp insert_variables(body, variables) do
    Map.put(body, :variables, variables)
  end

  defp url(options) do
    Keyword.get(options, :url) || Config.get(:url)
  end

  defp build_headers(options) do
    Keyword.merge(["Content-Type": "application/json"], headers(options))
  end

  defp headers(options) do
    Keyword.get(options, :headers, Config.get(:headers) || [])
  end
end