Extracted

Author: jechol

.formatter.exs

@@ -0,0 +1,14 @@
+spark_locals_without_parens = [except: 1, include_primary_read?: 1, sort: 1]
+
+[
+  import_deps: [:spark, :reactor, :ash],
+  inputs: [
+    "{mix,.formatter}.exs",
+    "{config,lib,test}/**/*.{ex,exs}"
+  ],
+  plugins: [Spark.Formatter],
+  locals_without_parens: spark_locals_without_parens,
+  export: [
+    locals_without_parens: spark_locals_without_parens
+  ]
+]

.github/workflows/elixir.yaml

@@ -0,0 +1,115 @@
+name: Elixir CI
+
+# Define workflow that runs when changes are pushed to the
+# `main` branch or pushed to a PR branch that targets the `main`
+# branch. Change the branch name if your project uses a
+# different name for the main branch like "master" or "production".
+on:
+  push:
+    branches: ["main"] # adapt branch for project
+  pull_request:
+    branches: ["main"] # adapt branch for project
+
+# Sets the ENV `MIX_ENV` to `test` for running tests
+env:
+  MIX_ENV: test
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    # Set up a Postgres DB service. By default, Phoenix applications
+    # use Postgres. This creates a database for running tests.
+    # Additional services can be defined here if required.
+    services:
+      db:
+        image: postgres:12
+        ports: ["5432:5432"]
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    runs-on: ubuntu-latest
+    name: Test on OTP ${{matrix.otp}} / Elixir ${{matrix.elixir}}
+    strategy:
+      # Specify the OTP and Elixir versions to use when building
+      # and running the workflow steps.
+      matrix:
+        otp: ["27.0.0.0"] # Define the OTP version [required]
+        elixir: ["1.18.0"] # Define the elixir version [required]
+    steps:
+      # Step: Identity Elixir + Erlang image as the base.
+      - name: Set up Elixir
+        uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{matrix.otp}}
+          elixir-version: ${{matrix.elixir}}
+
+      # Step: Check out the code.
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      # Step: Define how to cache deps. Restores existing cache if present.
+      - name: Cache deps
+        id: cache-deps
+        uses: actions/cache@v3
+        env:
+          cache-name: cache-elixir-deps
+        with:
+          path: deps
+          key: ${{ runner.os }}-mix-${{ env.cache-name }}-${{ hashFiles('**/mix.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-mix-${{ env.cache-name }}-
+
+      # Step: Define how to cache the `_build` directory. After the first run,
+      # this speeds up tests runs a lot. This includes not re-compiling our
+      # project's downloaded deps every run.
+      - name: Cache compiled build
+        id: cache-build
+        uses: actions/cache@v3
+        env:
+          cache-name: cache-compiled-build
+        with:
+          path: _build
+          key: ${{ runner.os }}-mix-${{ env.cache-name }}-${{ hashFiles('**/mix.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-mix-${{ env.cache-name }}-
+            ${{ runner.os }}-mix-
+
+      # Step: Conditionally bust the cache when job is re-run.
+      # Sometimes, we may have issues with incremental builds that are fixed by
+      # doing a full recompile. In order to not waste dev time on such trivial
+      # issues (while also reaping the time savings of incremental builds for
+      # *most* day-to-day development), force a full recompile only on builds
+      # that are retried.
+      - name: Clean to rule out incremental build as a source of flakiness
+        if: github.run_attempt != '1'
+        run: |
+          mix deps.clean --all
+          mix clean
+        shell: sh
+
+      # Step: Download project dependencies. If unchanged, uses
+      # the cached version.
+      - name: Install dependencies
+        run: mix deps.get
+
+      # Step: Compile the project treating any warnings as errors.
+      # Customize this step if a different behavior is desired.
+      - name: Compiles without warnings
+        run: mix compile --warnings-as-errors
+
+      # Step: Check that the checked in code has already been formatted.
+      # This step fails if something was found unformatted.
+      # Customize this step as desired.
+      - name: Check Formatting
+        run: mix format --check-formatted
+
+      # Step: Execute the tests.
+      - name: Run tests
+        run: mix test

.gitignore

@@ -0,0 +1,24 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+ash_always_select-*.tar
+
+# Temporary files, for example, from tests.
+/tmp/
+*.code-workspace

.tool-versions

@@ -0,0 +1,2 @@
+erlang 27.3
+elixir 1.18.3-otp-27

README.md

@@ -0,0 +1,54 @@
+# AshDefaultSort
+
+Configure a default sort to apply when a read action has no sort.
+
+## Installation
+
+Add `ash_default_sort` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:ash_default_sort, "~> 0.1.0"}
+  ]
+end
+```
+
+## Usage
+
+```elixir
+defmodule Post do
+  use Ash.Resource,
+    data_layer: Ash.DataLayer.Postgres,
+    extensions: [AshDefaultSort]
+
+  actions do
+    read :read do
+      primary? true
+    end
+  
+    read :read_sorted do
+      prepare build(sort: [id: :desc])
+    end
+
+    read :read_all do
+    end
+
+    read :read_every do
+    end
+
+  default_sort do
+    sort [like_count: :desc, created_at: :desc]
+    include_primary_read? false
+    except [:read_all]
+  end
+end
+```
+
+In the example above, [like_count: :desc, created_at: :desc] is applied to `read_every`.
+
+This is because `read` is excluded by `include_primary_read? false`, `read_sorted` is not affected because it already includes a sort, and `read_all` is excluded by the `except` option.
+
+## License
+
+MIT

config/config.exs

@@ -0,0 +1,3 @@
+import Config
+
+config :ash, :validate_domain_config_inclusion?, false

lib/ash_default_sort.ex

@@ -0,0 +1,42 @@
+defmodule AshDefaultSort do
+  @default_sort %Spark.Dsl.Section{
+    name: :default_sort,
+    describe: """
+    Configure a default sort to apply when a read action has no sort.
+    """,
+    examples: [
+      """
+      default_sort do
+        sort [user_id: :asc, created_at: :desc]
+        include_primary_read? true
+        except [:read_without_sort]
+      end
+      """
+    ],
+    schema: [
+      sort: [
+        type: :keyword_list,
+        required: false,
+        default: [],
+        doc: "The sort to apply when Ash.Query has no sort"
+      ],
+      include_primary_read?: [
+        type: :boolean,
+        required: false,
+        default: false,
+        doc: "Whether to apply to the primary read action as well"
+      ],
+      except: [
+        type: {:wrap_list, :atom},
+        required: false,
+        default: [],
+        doc: "List of read actions to exclude"
+      ]
+    ],
+    entities: []
+  }
+
+  use Spark.Dsl.Extension,
+    sections: [@default_sort],
+    transformers: [AshDefaultSort.Transformer]
+end

lib/info.ex

@@ -0,0 +1,3 @@
+defmodule AshDefaultSort.Info do
+  use Spark.InfoGenerator, extension: AshDefaultSort, sections: [:default_sort]
+end

lib/preparation.ex

@@ -0,0 +1,14 @@
+defmodule AshDefaultSort.Preparation do
+  use Ash.Resource.Preparation
+
+  def prepare(query, [sort: sort], _context) do
+    query
+    |> Ash.Query.before_action(fn
+      %Ash.Query{sort: [_ | _]} = sorted_query ->
+        sorted_query
+
+      %Ash.Query{sort: []} = unsorted_query ->
+        unsorted_query |> Ash.Query.sort(sort)
+    end)
+  end
+end

lib/transformer.ex

@@ -0,0 +1,36 @@
+defmodule AshDefaultSort.Transformer do
+  use Spark.Dsl.Transformer
+
+  alias Spark.Dsl.Transformer
+  alias Ash.Resource.Builder
+
+  def after?(_), do: true
+
+  def transform(dsl_state) do
+    sort = Transformer.get_option(dsl_state, [:default_sort], :sort)
+
+    include_primary_read? =
+      Transformer.get_option(dsl_state, [:default_sort], :include_primary_read?)
+
+    except = Transformer.get_option(dsl_state, [:default_sort], :except)
+
+    dsl_state
+    |> Transformer.get_entities([:actions])
+    |> Enum.filter(&(&1.type == :read))
+    |> 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})
+      %Ash.Resource.Actions.Read{read | preparations: preparations ++ [preparation]}
+    end)
+    |> Enum.reduce(dsl_state, fn action, dsl_state ->
+      Transformer.replace_entity(
+        dsl_state,
+        [:actions],
+        action,
+        &(&1.name == action.name)
+      )
+    end)
+    |> then(fn dsl_state -> {:ok, dsl_state} end)
+  end
+end