Add has_many_sort option (#1)

Co-authored-by: Jechol Lee <jechol@devall.org>

Author: rapidfsub

.formatter.exs

@@ -1,4 +1,4 @@
-spark_locals_without_parens = [except: 1, include_primary_read?: 1, sort: 1]
+spark_locals_without_parens = [except: 1, has_many_sort: 1, include_primary_read?: 1, sort: 1]
 
 [
   import_deps: [:spark, :reactor, :ash],

README.md

@@ -9,7 +9,7 @@ Add `ash_default_sort` to your list of dependencies in `mix.exs`:
 ```elixir
 def deps do
   [
-    {:ash_default_sort, "~> 0.1.0"}
+    {:ash_default_sort, "~> 0.2.0"}
   ]
 end
 ```

lib/ash_default_sort.ex

@@ -31,12 +31,21 @@ defmodule AshDefaultSort do
         required: false,
         default: [],
         doc: "List of read actions to exclude"
+      ],
+      has_many_sort: [
+        type: :keyword_list,
+        required: false,
+        default: [],
+        doc: "The sort to apply when a has_many relationship has no sort"
       ]
     ],
     entities: []
   }
 
   use Spark.Dsl.Extension,
     sections: [@default_sort],
-    transformers: [AshDefaultSort.Transformer]
+    transformers: [
+      AshDefaultSort.Sort.Transformer,
+      AshDefaultSort.HasManySort.Transformer
+    ]
 end

lib/ash_default_sort/has_many_sort/transformer.ex

@@ -0,0 +1,31 @@
+defmodule AshDefaultSort.HasManySort.Transformer do
+  use Spark.Dsl.Transformer
+  alias Spark.Dsl.Transformer
+
+  @impl Spark.Dsl.Transformer
+  def transform(dsl_state) do
+    except = Transformer.get_option(dsl_state, [:default_sort], :except)
+
+    case Transformer.get_option(dsl_state, [:default_sort], :has_many_sort) do
+      [] ->
+        dsl_state
+
+      has_many_sort ->
+        dsl_state
+        |> Transformer.get_entities([:relationships])
+        |> Enum.filter(&(&1.type == :has_many))
+        |> Enum.reject(&(&1.name in except))
+        |> Enum.reject(& &1.default_sort)
+        |> Enum.map(&%{&1 | default_sort: has_many_sort})
+        |> Enum.reduce(dsl_state, fn has_many, dsl_state ->
+          Transformer.replace_entity(
+            dsl_state,
+            [:relationships],
+            has_many,
+            &(&1.name == has_many.name)
+          )
+        end)
+    end
+    |> then(fn dsl_state -> {:ok, dsl_state} end)
+  end
+end

lib/info.ex lib/ash_default_sort/info.exlib/info.ex renamed to lib/ash_default_sort/info.ex

@@ -1,4 +1,4 @@
-defmodule AshDefaultSort.Preparation do
+defmodule AshDefaultSort.Sort.Preparation do
   use Ash.Resource.Preparation
 
   def prepare(query, [sort: sort], _context) do

lib/preparation.ex lib/ash_default_sort/sort/preparation.exlib/preparation.ex renamed to lib/ash_default_sort/sort/preparation.ex

@@ -1,4 +1,4 @@
-defmodule AshDefaultSort.Transformer do
+defmodule AshDefaultSort.Sort.Transformer do
   use Spark.Dsl.Transformer
 
   alias Spark.Dsl.Transformer
@@ -20,7 +20,9 @@ defmodule AshDefaultSort.Transformer do
     |> Enum.reject(&(&1.name in except))
     |> Enum.reject(&(&1.primary? && !include_primary_read?))
     |> Enum.map(fn %Ash.Resource.Actions.Read{preparations: preparations} = read ->
-      {:ok, preparation} = Builder.build_preparation({AshDefaultSort.Preparation, sort: sort})
+      {:ok, preparation} =
+        Builder.build_preparation({AshDefaultSort.Sort.Preparation, sort: sort})
+
       %Ash.Resource.Actions.Read{read | preparations: preparations ++ [preparation]}
     end)
     |> Enum.reduce(dsl_state, fn action, dsl_state ->

lib/transformer.ex lib/ash_default_sort/sort/transformer.exlib/transformer.ex renamed to lib/ash_default_sort/sort/transformer.ex

@@ -4,7 +4,7 @@ defmodule AshDefaultSort.MixProject do
   def project do
     [
       app: :ash_default_sort,
-      version: "0.1.0",
+      version: "0.2.0",
       elixir: "~> 1.17",
       consolidate_protocols: Mix.env() not in [:dev, :test],
       start_permanent: Mix.env() == :prod,

mix.exs

@@ -0,0 +1,80 @@
+defmodule AshDefaultSort.HasManySortTest do
+  use ExUnit.Case, async: true
+
+  alias __MODULE__.{TodoList, Task, Domain}
+
+  defmodule TodoList do
+    use Ash.Resource,
+      data_layer: Ash.DataLayer.Ets,
+      domain: Domain,
+      extensions: [AshDefaultSort]
+
+    attributes do
+      uuid_v7_primary_key :id
+      attribute :title, :string, allow_nil?: false, public?: true
+    end
+
+    relationships do
+      has_many :tasks, Task
+    end
+
+    actions do
+      defaults [:read, create: :*]
+
+      update :add_task do
+        require_atomic? false
+        argument :task, :map, allow_nil?: false
+        change manage_relationship(:task, :tasks, type: :create)
+      end
+    end
+
+    default_sort do
+      has_many_sort priority: :asc
+    end
+  end
+
+  defmodule Task do
+    use Ash.Resource,
+      data_layer: Ash.DataLayer.Ets,
+      domain: Domain,
+      extensions: [AshDefaultSort]
+
+    attributes do
+      uuid_v7_primary_key :id
+      attribute :priority, :integer, allow_nil?: false, public?: true
+    end
+
+    relationships do
+      belongs_to :todo_list, TodoList
+    end
+
+    actions do
+      defaults [:read, create: :*]
+    end
+
+    default_sort do
+    end
+  end
+
+  defmodule Domain do
+    use Ash.Domain
+
+    resources do
+      resource TodoList
+      resource Task
+    end
+  end
+
+  test "pass" do
+    params = %{title: "Todo List 1"}
+    list = Ash.Changeset.for_create(TodoList, :create, params) |> Ash.create!()
+
+    for priority <- Enum.concat(1..5//2, 2..5//2) do
+      params = %{task: %{priority: priority}}
+      Ash.Changeset.for_update(list, :add_task, params) |> Ash.update!()
+    end
+
+    list = Ash.load!(list, [:tasks])
+    assert [1, 2, 3, 4, 5] = Enum.map(list.tasks, & &1.priority)
+  end
+end

test/ash_default_sort/has_many_sort_test.exs

@@ -0,0 +1,46 @@
+defmodule AshDefaultSort.SortTest do
+  use ExUnit.Case, async: true
+
+  alias __MODULE__.{Obj, Domain}
+
+  defmodule Obj do
+    use Ash.Resource,
+      data_layer: Ash.DataLayer.Ets,
+      domain: Domain,
+      extensions: [AshDefaultSort]
+
+    attributes do
+      uuid_v7_primary_key :id
+      attribute :age, :integer, allow_nil?: false, public?: true
+    end
+
+    actions do
+      defaults [:read, create: :*]
+      read :list
+    end
+
+    default_sort do
+      sort age: :desc
+    end
+  end
+
+  defmodule Domain do
+    use Ash.Domain
+
+    resources do
+      resource Obj
+    end
+  end
+
+  test "pass" do
+    for age <- Enum.concat(1..5//2, 2..5//2) do
+      Ash.Changeset.for_create(Obj, :create, %{age: age}) |> Ash.create!()
+    end
+
+    assert [1, 3, 5, 2, 4] =
+             Ash.Query.for_read(Obj, :read) |> Ash.read!() |> Enum.map(& &1.age)
+
+    assert [5, 4, 3, 2, 1] =
+             Ash.Query.for_read(Obj, :list) |> Ash.read!() |> Enum.map(& &1.age)
+  end
+end