v1.2: Build errors from Blueprint tree (#153)

* Towards resolution building Phase.Error structs

* 484 tests, 22 failures & field suggestions

* Validation: VariablesAreInputTypes, tests

* GREEN

* ScalarLeafs validation

* Basic pipeline tests, hook in ScalarLeafs

Author: bruce

lib/absinthe/blueprint/document/result.ex

@@ -0,0 +1,10 @@
+defmodule Absinthe.Blueprint.Document.Result do
+
+  alias __MODULE__
+
+  @type t ::
+      Result.Object
+    | Result.List
+    | Result.Leaf
+
+end

lib/absinthe/blueprint/document/result/leaf.ex

@@ -1,9 +1,20 @@
 defmodule Absinthe.Blueprint.Document.Result.Leaf do
 
+  alias Absinthe.{Blueprint, Phase}
+
   @enforce_keys [:emitter, :value]
   defstruct [
     :emitter,
-    :value
+    :value,
+    errors: [],
+    flags: %{}
   ]
 
+  @type t :: %__MODULE__{
+    emitter: Blueprint.Document.Field.t,
+    value: Blueprint.Document.Result.t,
+    errors: [Phase.Error.t],
+    flags: [Blueprint.flag_t],
+  }
+
 end

lib/absinthe/blueprint/document/result/list.ex

@@ -1,9 +1,21 @@
 defmodule Absinthe.Blueprint.Document.Result.List do
 
+  alias Absinthe.{Blueprint, Phase}
+
   @enforce_keys [:emitter, :values]
   defstruct [
     :emitter,
-    :values
+    :values,
+    # Added by phases
+    errors: [],
+    flags: %{}
   ]
 
+  @type t :: %__MODULE__{
+    emitter: Blueprint.Document.Field.t,
+    values: [Blueprint.Document.Result.t],
+    errors: [Phase.Error.t],
+    flags: [Blueprint.flag_t],
+  }
+
 end

lib/absinthe/blueprint/document/result/object.ex

@@ -1,9 +1,21 @@
 defmodule Absinthe.Blueprint.Document.Result.Object do
 
+  alias Absinthe.{Blueprint, Phase}
+
   @enforce_keys [:emitter, :fields]
   defstruct [
     :emitter,
     :fields,
+    # Added by phases
+    errors: [],
+    flags: %{}
   ]
 
+  @type t :: %__MODULE__{
+    emitter: Blueprint.Document.Field.t,
+    fields: [Blueprint.Document.Result.t],
+    errors: [Phase.Error.t],
+    flags: [Blueprint.flag_t]
+  }
+
 end

lib/absinthe/blueprint/document/variable_definition.ex

@@ -12,7 +12,7 @@ defmodule Absinthe.Blueprint.Document.VariableDefinition do
     flags: %{},
     provided_value: nil,
     errors: [],
-    schema_type: nil,
+    schema_node: nil,
   ]
 
   @type t :: %__MODULE__{
@@ -23,7 +23,7 @@ defmodule Absinthe.Blueprint.Document.VariableDefinition do
     provided_value: nil | Blueprint.Input.t,
     errors: [Absinthe.Phase.Error.t],
     flags: Blueprint.flags_t,
-    schema_type: Type.t,
+    schema_node: Type.t,
   }
 
 end

lib/absinthe/blueprint/input.ex

@@ -102,5 +102,8 @@ defmodule Absinthe.Blueprint.Input do
   def inspect(nil) do
     "null"
   end
+  def inspect(other) do
+    Kernel.inspect(other)
+  end
 
 end

lib/absinthe/phase/debug.ex

@@ -5,7 +5,9 @@ defmodule Absinthe.Phase.Debug do
 
   @spec run(any) :: {:ok, Blueprint.t}
   def run(input) do
-    IO.inspect(input)
+    if System.get_env("DEBUG") do
+      IO.inspect(input)
+    end
     {:ok, input}
   end
 

lib/absinthe/phase/document/arguments/data.ex

@@ -71,7 +71,7 @@ defmodule Absinthe.Phase.Document.Arguments.Data do
         other
     end
   end
-  defp build_value(%Blueprint.Input.Object{} = node, adapter) do
+  defp build_value(%Blueprint.Input.Object{schema_node: %{fields: _}} = node, adapter) do
     {result, fields} = node.fields
     |> Enum.reduce({%{}, []}, fn
       field, {data, fields} ->

lib/absinthe/phase/document/cascade_invalid.ex

@@ -0,0 +1,38 @@
+defmodule Absinthe.Phase.Document.CascadeInvalid do
+  @moduledoc """
+  Ensure any nodes whose children are invalid that need to be made
+  invalid is marked invalid.
+  """
+
+  use Absinthe.Phase
+
+  alias Absinthe.Blueprint
+
+  @spec run(Blueprint.t) :: {:ok, Blueprint.t}
+  def run(input) do
+    result = Blueprint.update_current(input, &process(&1, input.schema))
+    {:ok, result}
+  end
+
+  defp process(operation, schema) do
+    Blueprint.prewalk(operation, &handle_node(&1, schema))
+  end
+
+  defp handle_node(%Blueprint.Document.Field{} = node, schema) do
+    node = if any_invalid?(node.arguments) do
+      node |> flag_invalid(:bad_arguments)
+    else
+      node
+    end
+    node = if any_invalid?(node.directives) do
+      node |> flag_invalid(:bad_directives)
+    else
+      node
+    end
+    node
+  end
+  defp handle_node(node, _) do
+    node
+  end
+
+end

lib/absinthe/phase/document/execution/data.ex

@@ -4,27 +4,40 @@ defmodule Absinthe.Phase.Document.Execution.Data do
   Produces data fit for external encoding from annotated value tree
   """
 
-  alias Absinthe.Blueprint
+  alias Absinthe.{Blueprint, Phase}
   use Absinthe.Phase
 
   def run(blueprint) do
-    result = blueprint
-    |> Blueprint.current_operation
-    |> process
-    |> clean
+    result = blueprint |> process
     {:ok, result}
   end
 
-  defp process(%Blueprint.Document.Operation{resolution: tree}) do
-    {data, errors} = field_data(tree.fields, [])
-    %{data: data, errors: errors}
+  defp process(%Blueprint{} = blueprint) do
+    {_, document_errors} = Blueprint.prewalk(blueprint, [], &document_errors/2)
+    {data, errors} = case Blueprint.current_operation(blueprint) do
+      nil ->
+        {nil, document_errors}
+      op ->
+        field_data(op.resolution.fields, document_errors)
+    end
+    {:ok, format_result(data, errors |> Enum.uniq)}
   end
 
-  defp clean(%{data: data} = result) when map_size(data) == 0 do
-    Map.delete(result, :data)
+  defp format_result(nil, errors) do
+    %{data: %{}, errors: Enum.map(errors, &format_error/1)}
   end
-  defp clean(%{errors: []} = result) do
-    Map.delete(result, :errors)
+  defp format_result(data, []) do
+    %{data: data}
+  end
+  defp format_result(data, errors) do
+    %{data: data, errors: Enum.map(errors, &format_error/1)}
+  end
+
+  defp document_errors(%{errors: errs} = node, acc) do
+    {node, acc ++ errs}
+  end
+  defp document_errors(node, acc) do
+    {node, acc}
   end
 
   # Leaf
@@ -38,25 +51,37 @@ defmodule Absinthe.Phase.Document.Execution.Data do
 
   defp list_data(fields, errors, acc \\ [])
   defp list_data([], errors, acc), do: {:lists.reverse(acc), errors}
-  defp list_data([{:ok, field} | fields], errors, acc) do
+  defp list_data([%{errors: []} = field | fields], errors, acc) do
     {value, errors} = data(field, errors)
     list_data(fields, errors, [value | acc])
   end
-  defp list_data([{:error, error} | fields], errors, acc) do
-    list_data(fields, List.wrap(error) ++ errors, acc)
+  defp list_data([%{errors: errs} = field | fields], errors, acc) when length(errs) > 0 do
+    list_data(fields, errs ++ errors, acc)
   end
 
   defp field_data(fields, errors, acc \\ [])
   defp field_data([], errors, acc), do: {:maps.from_list(acc), errors}
-  defp field_data([{:ok, field} | fields], errors, acc) do
+  defp field_data([%{errors: []} = field | fields], errors, acc) do
     {value, errors} = data(field, errors)
     field_data(fields, errors, [{field_name(field), value} | acc])
   end
-  defp field_data([{:error, error} | fields], errors, acc) do
-    field_data(fields, List.wrap(error) ++ errors, acc)
+  defp field_data([%{errors: errs} = field | fields], errors, acc) when length(errs) > 0 do
+    field_data(fields, errs ++ errors, acc)
   end
 
   defp field_name(%{emitter: %{alias: nil, name: name}}), do: name
   defp field_name(%{emitter: %{alias: name}}), do: name
   defp field_name(%{emitter: %{name: name}}), do: name
+
+  defp format_error(%Phase.Error{locations: []} = error) do
+    %{message: error.message}
+  end
+  defp format_error(%Phase.Error{} = error) do
+    %{message: error.message, locations: Enum.map(error.locations, &format_location/1)}
+  end
+
+  defp format_location(%{line: line, column: col}) do
+    %{line: line || 0, column: col || 0}
+  end
+
 end