Add 'ordered_by_direction' option so we can sort the 'ordered_by' field.

Author: seanabrahams

lib/graphql/relay/connection/ecto.ex

@@ -57,23 +57,60 @@ if Code.ensure_loaded?(Ecto) do
       resolve(repo, query, args)
     end
 
+    @doc """
+    Pass in an Ecto.Repo, an Ecto.Query, and Relay args to have the query
+    executed and results returned in the format Relay requires.
+
+    If you wish to have the results ordered by some field other than `id`,
+    use `ordered_by` and `ordered_by_direction`.
+
+    Example for returning data in reverse chronological order (newest first)
+    like you would do for a page listing blog posts:
+
+      args = %{
+        first: 10,
+        ordered_by: :inserted_at,
+        ordered_by_direction: :desc
+      }
+
+    Your GraphQL resolve function for the connection will look something like:
+
+      resolve: fn(blog, args, _ctx) ->
+        # Order by desc inserted_at
+        args = Map.merge(args, %{ordered_by: :inserted_at, ordered_by_direction: :desc})
+        query = Ecto.assoc(blog, :posts)
+        GraphQL.Relay.Connection.Ecto.resolve(Repo, query, args)
+      end
+    """
     def resolve(repo, query, args \\ %{}) do
       before = cursor_to_offset(args[:before])
       # `after` is a keyword http://elixir-lang.org/docs/master/elixir/Kernel.SpecialForms.html#try/1
       a_after = cursor_to_offset(args[:after])
       first = args[:first]
       last = args[:last]
       ordered_by_property = args[:ordered_by] || :id
+      ordered_by_direction = get_ordered_by_direction(args[:ordered_by_direction] || :asc)
+      opposite_ordered_by_direction = if ordered_by_direction == :asc, do: :desc, else: :asc
       limit = Enum.min([first, last, connection_count(repo, query)])
 
       query = if a_after do
-        query |> where([a], field(a, ^ordered_by_property) > ^a_after)
+        case ordered_by_direction do
+          :asc ->
+            query |> where([a], field(a, ^ordered_by_property) > ^a_after)
+          :desc ->
+            query |> where([a], field(a, ^ordered_by_property) < ^a_after)
+        end
       else
         query
       end
 
       query = if before do
-        query |> where([a], field(a, ^ordered_by_property) < ^before)
+        case ordered_by_direction do
+          :asc ->
+            query |> where([a], field(a, ^ordered_by_property) < ^before)
+          :desc ->
+            query |> where([a], field(a, ^ordered_by_property) > ^before)
+        end
       else
         query
       end
@@ -98,13 +135,15 @@ if Code.ensure_loaded?(Ecto) do
       end
 
       query = if first do
-        query |> order_by(asc: ^ordered_by_property) |> limit(^limit)
+        sort_values = Keyword.new([{ordered_by_direction, ordered_by_property}])
+        query |> order_by(^sort_values) |> limit(^limit)
       else
         query
       end
 
       query = if last do
-        query |> order_by(desc: ^ordered_by_property) |> limit(^limit)
+        sort_values = Keyword.new([{opposite_ordered_by_direction, ordered_by_property}])
+        query |> order_by(^sort_values) |> limit(^limit)
       else
         query
       end
@@ -166,6 +205,10 @@ if Code.ensure_loaded?(Ecto) do
       repo.one(count_query)
     end
 
+    defp get_ordered_by_direction(value) when value in [:asc, :desc] do
+      value
+    end
+
     defp make_query_countable(query) do
       query
       |> remove_order

test/graphql/relay/connection/ecto_test.exs

@@ -235,6 +235,22 @@ defmodule GraphQL.Relay.Connection.EctoTest do
     assert(Connection.Ecto.resolve(Repo, letters_query, %{first: 2, after: edge_for_object(b, :order).cursor, ordered_by: :order}) == expected)
   end
 
+  test "pagination: respects first and after with non-default ordered_by and ordered_by_direction" do
+    expected = %{
+      edges: [
+        edge_for_object(d, :order),
+        edge_for_object(c, :order),
+      ],
+      pageInfo: %{
+        startCursor: edge_for_object(d, :order).cursor,
+        endCursor: edge_for_object(c, :order).cursor,
+        hasPreviousPage: false,
+        hasNextPage: true,
+      }
+    }
+    assert(Connection.Ecto.resolve(Repo, letters_query, %{first: 2, after: edge_for_object(e, :order).cursor, ordered_by: :order, ordered_by_direction: :desc}) == expected)
+  end
+
   test "respects first and after with long first" do
     expected = %{
       edges: [