Separating out the main plug to have two versions.

* Version that can only execute queries * Seperate version that can load GraphiQL

Author: aweiker

lib/graphql/plug.ex

@@ -26,25 +26,26 @@ defmodule GraphQL.Plug do
  pass: ["*/*"],
  json_decoder: Poison
 
- plug GraphQL.Plug.Endpoint
+ # plug GraphQL.Plug.Endpoint
+
  # TODO extract
  # plug GraphQL.Plug.GraphiQL
 
- # TODO remove duplication call GraphQL.Plug.Helper.extract_init_options/1 here
  def init(opts) do
- schema = case Keyword.get(opts, :schema) do
- {mod, func} -> apply(mod, func, [])
- s -> s
- end
- root_value = Keyword.get(opts, :root_value, %{})
- %{:schema => schema, :root_value => root_value}
+ GraphQL.Plug.BareEndpoint.init(opts)
  end
 
  def call(conn, opts) do
  # TODO use private
  conn = assign(conn, :graphql_options, opts)
  conn = super(conn, opts)
 
+ conn = if allow_graphiql? do
+ GraphQL.Plug.Endpoint.call(conn, opts)
+ else
+ GraphQL.Plug.BareEndpoint.call(conn, opts)
+ end
+
  # TODO consider not logging instrospection queries
  Logger.debug """
  Processed GraphQL query:
@@ -54,4 +55,9 @@ defmodule GraphQL.Plug do
 
  conn
  end
+
+ defp allow_graphiql? do
+ config = Application.get_env(:plug_graphql, __MODULE__, [])
+ Keyword.get(config, :allow_graphiql, false)
+ end
 end

lib/graphql/plug/bare_endpoint.ex

@@ -0,0 +1,83 @@
+defmodule GraphQL.Plug.BareEndpoint do
+ @moduledoc """
+ This is the core plug for mounting a GraphQL server.
+
+ You can build your own pipeline by mounting the
+ `GraphQL.Plug.Endpoint` plug directly.
+
+ ```elixir
+ forward "/graphql", GraphQL.Plug.Endpoint, schema: {MyApp.Schema, :schema}
+ ```
+
+ You may want to look at how `GraphQL.Plug` configures its pipeline.
+ Specifically note how `Plug.Parsers` are configured, as this is required
+ for pre-parsing the various POST bodies depending on `content-type`.
+
+ This plug currently includes _GraphiQL_ support but this should end
+ up in it's own plug.
+ """
+
+ import Plug.Conn
+ alias Plug.Conn
+ alias GraphQL.Plug.RootValue
+ alias GraphQL.Plug.Parameters
+
+ @behaviour Plug
+
+ def init(opts) do
+ schema = case Keyword.get(opts, :schema) do
+ {mod, func} -> apply(mod, func, [])
+ s -> s
+ end
+ root_value = Keyword.get(opts, :root_value, %{})
+ %{schema: schema, root_value: root_value}
+ end
+
+ def call(%Conn{method: m} = conn, opts) when m in ["GET", "POST"] do
+ %{schema: schema, root_value: root_value} = conn.assigns[:graphql_options] || opts
+
+ query = Parameters.query(conn)
+ variables = Parameters.variables(conn)
+ operation_name = Parameters.operation_name(conn)
+ evaluated_root_value = RootValue.evaluate(conn, root_value)
+
+ cond do
+ query ->
+ handle_call(conn, schema, evaluated_root_value, query, variables, operation_name)
+ true ->
+ handle_error(conn, "Must provide query string.")
+ end
+ end
+
+ def call(%Conn{method: _} = conn, _) do
+ handle_error(conn, "GraphQL only supports GET and POST requests.")
+ end
+
+ def handle_error(conn, message) do
+ {:ok, errors} = Poison.encode %{errors: [%{message: message}]}
+ conn
+ |> put_resp_content_type("application/json")
+ |> send_resp(400, errors)
+ end
+
+ def handle_call(conn, schema, root_value, query, variables, operation_name) do
+ conn
+ |> put_resp_content_type("application/json")
+ |> execute(schema, root_value, query, variables, operation_name)
+ end
+
+ defp execute(conn, schema, root_value, query, variables, operation_name) do
+ case GraphQL.execute(schema, query, root_value, variables, operation_name) do
+ {:ok, data} ->
+ case Poison.encode(data) do
+ {:ok, json} -> send_resp(conn, 200, json)
+ {:error, errors} -> send_resp(conn, 400, errors)
+ end
+ {:error, errors} ->
+ case Poison.encode(errors) do
+ {:ok, json} -> send_resp(conn, 400, json)
+ {:error, errors} -> send_resp(conn, 400, errors)
+ end
+ end
+ end
+end

lib/graphql/plug/endpoint.ex

@@ -19,6 +19,9 @@ defmodule GraphQL.Plug.Endpoint do
 
  import Plug.Conn
  alias Plug.Conn
+ alias GraphQL.Plug.BareEndpoint
+ alias GraphQL.Plug.RootValue
+ alias GraphQL.Plug.Parameters
 
  @behaviour Plug
 
@@ -46,40 +49,29 @@ defmodule GraphQL.Plug.Endpoint do
  [:graphiql_version, :query, :variables, :result]
 
  def init(opts) do
- schema = case Keyword.get(opts, :schema) do
- {mod, func} -> apply(mod, func, [])
- s -> s
- end
- root_value = Keyword.get(opts, :root_value, %{})
- %{schema: schema, root_value: root_value}
+ BareEndpoint.init(opts)
  end
 
  def call(%Conn{method: m} = conn, opts) when m in ["GET", "POST"] do
  %{schema: schema, root_value: root_value} = conn.assigns[:graphql_options] || opts
 
- query = query(conn)
- variables = variables(conn)
- operation_name = operation_name(conn)
- evaluated_root_value = evaluate_root_value(conn, root_value)
+ query = Parameters.query(conn)
+ variables = Parameters.variables(conn)
+ operation_name = Parameters.operation_name(conn)
+ evaluated_root_value = RootValue.evaluate(conn, root_value)
 
  cond do
  use_graphiql?(conn) ->
  handle_graphiql_call(conn, schema, evaluated_root_value, query, variables, operation_name)
  query ->
- handle_call(conn, schema, evaluated_root_value, query, variables, operation_name)
+ BareEndpoint.handle_call(conn, schema, evaluated_root_value, query, variables, operation_name)
  true ->
- handle_error(conn, "Must provide query string.")
+ BareEndpoint.handle_error(conn, "Must provide query string.")
  end
  end
 
  def call(%Conn{method: _} = conn, _) do
- handle_error(conn, "GraphQL only supports GET and POST requests.")
- end
-
- defp handle_call(conn, schema, root_value, query, variables, operation_name) do
- conn
- |> put_resp_content_type("application/json")
- |> execute(schema, root_value, query, variables, operation_name)
+ BareEndpoint.handle_error(conn, "GraphQL only supports GET and POST requests.")
  end
 
  defp escape_string(s) do
@@ -94,72 +86,13 @@ defmodule GraphQL.Plug.Endpoint do
  {_, data} = GraphQL.execute(schema, query, root_value, variables, operation_name)
  {:ok, variables} = Poison.encode(variables, pretty: true)
  {:ok, result} = Poison.encode(data, pretty: true)
+
  graphiql = graphiql_html(@graphiql_version, escape_string(query), escape_string(variables), escape_string(result))
  conn
  |> put_resp_content_type("text/html")
  |> send_resp(200, graphiql)
  end
 
- defp handle_error(conn, message) do
- {:ok, errors} = Poison.encode %{errors: [%{message: message}]}
- conn
- |> put_resp_content_type("application/json")
- |> send_resp(400, errors)
- end
-
- defp execute(conn, schema, root_value, query, variables, operation_name) do
- case GraphQL.execute(schema, query, root_value, variables, operation_name) do
- {:ok, data} ->
- case Poison.encode(data) do
- {:ok, json} -> send_resp(conn, 200, json)
- {:error, errors} -> send_resp(conn, 400, errors)
- end
- {:error, errors} ->
- case Poison.encode(errors) do
- {:ok, json} -> send_resp(conn, 400, json)
- {:error, errors} -> send_resp(conn, 400, errors)
- end
- end
- end
-
- defp evaluate_root_value(conn, {mod, func}) do
- apply(mod, func, [conn])
- end
-
- defp evaluate_root_value(conn, root_fn) when is_function(root_fn, 1) do
- apply(root_fn, [conn])
- end
-
- defp evaluate_root_value(_, nil) do
- %{}
- end
-
- defp evaluate_root_value(_, root_value) do
- root_value
- end
-
- defp query(conn) do
- query = Map.get(conn.params, "query")
- if query && String.strip(query) != "", do: query, else: nil
- end
-
- defp variables(conn) do
- decode_variables Map.get(conn.params, "variables", %{})
- end
-
- defp decode_variables(variables) when is_binary(variables) do
- case Poison.decode(variables) do
- {:ok, variables} -> variables
- {:error, _} -> %{} # express-graphql ignores these errors currently
- end
- end
- defp decode_variables(vars), do: vars
-
- defp operation_name(conn) do
- Map.get(conn.params, "operationName") ||
- Map.get(conn.params, "operation_name")
- end
-
  defp use_graphiql?(conn) do
  case get_req_header(conn, "accept") do
  [accept_header | _] ->

lib/graphql/plug/parameters.ex

@@ -0,0 +1,32 @@
+defmodule GraphQL.Plug.Parameters do
+ @moduledoc """
+ This module provides the functions for parsing out parameters
+ from a `Plug.Conn`
+ """
+ 
+ @spec operation_name(Plug.Conn.t) :: String.t
+ def operation_name(conn) do
+ Map.get(conn.params, "operationName") ||
+ Map.get(conn.params, "operation_name")
+ end
+
+ @spec query(Plug.Conn.t) :: String.t | nil
+ def query(conn) do
+ query = Map.get(conn.params, "query")
+ if query && String.strip(query) != "", do: query, else: nil
+ end
+
+ @spec variables(Plug.Conn.t) :: Map
+ def variables(conn) do
+ decode_variables Map.get(conn.params, "variables", %{})
+ end
+
+ defp decode_variables(variables) when is_binary(variables) do
+ case Poison.decode(variables) do
+ {:ok, variables} -> variables
+ {:error, _} -> %{} # express-graphql ignores these errors currently
+ end
+ end
+ defp decode_variables(vars), do: vars
+
+end

lib/graphql/plug/root_value.ex

@@ -0,0 +1,25 @@
+defmodule GraphQL.Plug.RootValue do
+ @moduledoc """
+ This module provides the functions that are used for
+ evaluating the root value in the Plug prior to submitting
+ the query for execution.
+ """
+ @type root_value :: {module, atom} | (Plug.Conn.t -> Map) | Map | nil
+ @spec evaluate(Plug.Conn.t, root_value) :: Map
+
+ def evaluate(conn, {mod, func}) do
+ apply(mod, func, [conn])
+ end
+
+ def evaluate(conn, root_fn) when is_function(root_fn, 1) do
+ apply(root_fn, [conn])
+ end
+
+ def evaluate(_, nil) do
+ %{}
+ end
+
+ def evaluate(_, root_value) do
+ root_value
+ end
+end

mix.exs

@@ -26,6 +26,7 @@ defmodule GraphQL.Plug.Mixfile do
  defp deps do
  [{:earmark, "~> 0.1", only: :dev},
  {:ex_doc, "~> 0.11", only: :dev},
+ {:mix_test_watch, only: :dev},
  {:cowboy, "~> 1.0"},
  {:plug, "~> 0.14 or ~> 1.0"},
  {:poison, "~> 1.5 or ~> 2.0"},

mix.lock

@@ -2,7 +2,9 @@
  "cowlib": {:hex, :cowlib, "1.0.2"},
  "earmark": {:hex, :earmark, "0.1.19"},
  "ex_doc": {:hex, :ex_doc, "0.11.0"},
+ "fs": {:hex, :fs, "0.9.2"},
  "graphql": {:hex, :graphql, "0.1.2"},
+ "mix_test_watch": {:hex, :mix_test_watch, "0.2.6"},
  "plug": {:hex, :plug, "1.0.2"},
  "poison": {:hex, :poison, "2.1.0"},
  "ranch": {:hex, :ranch, "1.2.0"}}