Use ArrayMaps to represent lists in intermediate result representation

Author: freshtonic

lib/graphql/execution/executor.ex

@@ -12,6 +12,7 @@ defmodule GraphQL.Execution.Executor do
   alias GraphQL.Type.CompositeType
   alias GraphQL.Type.AbstractType
   alias GraphQL.Lang.AST.Nodes
+  alias GraphQL.Util.ArrayMap
 
   @type result_data :: {:ok, Map}
 
@@ -45,17 +46,33 @@ defmodule GraphQL.Execution.Executor do
     case operation.operation do
       :query        ->
         {context, result} = execute_fields(context, type, root_value, fields)
-        {:ok, result, context.errors}
+        {:ok, expand_array_maps(result), context.errors}
       :mutation     ->
         {context, result} = execute_fields_serially(context, type, root_value, fields)
-        {:ok, result, context.errors}
+        {:ok, expand_array_maps(result), context.errors}
       :subscription ->
         {:error, "Subscriptions not currently supported"}
       _             ->
         {:error, "Can only execute queries, mutations and subscriptions"}
     end
   end
 
+  defp expand_array_maps(result) when is_list(result) do
+    Enum.map(result, &expand_array_maps/1)
+  end
+  defp expand_array_maps(%ArrayMap{} = result) do
+    Enum.reduce(Enum.sort(Map.keys(result.map)), [], fn(index, acc) ->
+      [expand_array_maps(Map.get(result.map, index))] ++ acc
+    end) |> Enum.reverse
+  end
+  defp expand_array_maps(result) when is_map(result) do
+    Enum.reduce(result, %{}, fn({k, v}, acc) ->
+      Map.put(acc, expand_array_maps(k), expand_array_maps(v))
+    end)
+  end
+  defp expand_array_maps(result), do: result
+
+
   defp collect_selections(context, runtime_type, selection_set, field_fragment_map \\ %{fields: %{}, fragments: %{}}) do
     Enum.reduce selection_set[:selections], {context, field_fragment_map}, fn(selection, {context, field_fragment_map}) ->
       collect_selection(context, runtime_type, selection, field_fragment_map)
@@ -193,11 +210,11 @@ defmodule GraphQL.Execution.Executor do
 
   @spec complete_value(%List{}, ExecutionContext.t, GraphQL.Document.t, any, any) :: map
   defp complete_value(%List{ofType: list_type}, context, field_asts, info, result) do
-    {context, result} = Enum.reduce result, {context, []}, fn(item, {context, acc}) ->
+    {context, value, _} = Enum.reduce result, {context, %ArrayMap{}, 0}, fn(item, {context, acc, count}) ->
       {context, value} = complete_value(unwrap_type(list_type), context, field_asts, info, item)
-      {context, [value] ++ acc}
+      {context, ArrayMap.put(acc, count, value), count + 1}
     end
-    {context, Enum.reverse(result)}
+    {context, value}
   end
 
   defp complete_value(return_type, context, field_asts, info, result) when is_atom(return_type) do

lib/graphql/util/array_map.ex

@@ -0,0 +1,39 @@
+
+# ArrayMap is used for representing lists in intermediate results.
+# This means the entire intermediate Executor result representation can
+# be manipulated with the Access protocol which will allow for patching
+# the entire structure in an ad-hoc manner. This is key to implementing
+# deferred resolvers.
+defmodule GraphQL.Util.ArrayMap do
+
+  @behaviour Access
+
+  defstruct map: %{}
+
+  def put(array_map, index, value) when is_integer(index) do
+    %__MODULE__{ map: Map.put(array_map.map, index, value) }
+  end
+
+  # Access behaviour
+  def fetch(array_map, key) do
+    case Access.fetch(array_map.map, key) do
+      {:ok, value} -> %__MODULE__{map: value}
+      :error -> :error
+    end
+  end
+
+  def get_and_update(array_map, key, list) do
+    {value, map} = Access.get_and_update(array_map.map, key, list)
+    {value, %__MODULE__{map: map}}
+  end
+
+  def get(array_map, key, value) do
+    map = Access.get(array_map.map, key, value)
+    %__MODULE__{map: value}
+  end
+
+  def pop(array_map, key) do
+    {value, map} = Access.get(array_map.map, key)
+    {value, %__MODULE__{map: map}}
+  end
+end

test/graphql/util/array_map_test.exs

@@ -0,0 +1,15 @@
+
+defmodule GraphQL.Util.ArrayMapTest do
+  use ExUnit.Case, async: true
+
+  alias GraphQL.Util.ArrayMap
+
+  test "implements Access" do
+    version_1 = %ArrayMap{map: %{0 => :zero, 1 => :one, 2 => :two}}
+    version_2 = %ArrayMap{map: %{0 => :zero, 1 => :ONE, 2 => :two}}
+
+    version_1_updated = put_in(version_1, [1], :ONE)
+
+    assert version_2 == version_1_updated
+  end
+end