lib/membership/custom_field_value.ex

@@ -48,6 +48,13 @@ defmodule Mv.Membership.CustomFieldValue do
     table "custom_field_values"
     repo Mv.Repo
 
+    custom_indexes do
+      # GIN index on the JSONB value to serve boolean custom-field containment
+      # predicates (`value @> '{"value": <bool>}'`) used by the member overview.
+      # Default jsonb_ops supports the `@>` operator we rely on.
+      index ["value"], name: "custom_field_values_value_gin_index", using: "gin"
+    end
+
     references do
       reference :member, on_delete: :delete
       reference :custom_field, on_delete: :delete
@@ -133,6 +140,16 @@ defmodule Mv.Membership.CustomFieldValue do
 
   calculations do
     calculate :value_to_string, :string, expr(value[:value] <> "")
+
+    # Typed sort keys for DB-side ordering of the member overview by a custom
+    # field. The stored JSONB value (`{"type": ..., "value": ...}`) is cast per
+    # the field's value type so integers sort numerically and dates
+    # chronologically. Empty strings collapse to NULL so they sort last, matching
+    # the previous in-memory `CustomFieldSort` behaviour.
+    calculate :sort_text, :string, expr(fragment("nullif(?->>'value','')", value))
+    calculate :sort_numeric, :decimal, expr(fragment("nullif(?->>'value','')::numeric", value))
+    calculate :sort_date, :date, expr(fragment("nullif(?->>'value','')::date", value))
+    calculate :sort_boolean, :boolean, expr(fragment("nullif(?->>'value','')::boolean", value))
   end
 
   # Ensure a member can only have one custom field value per custom field

lib/mv_web/live/member_live/index/date_filter.ex

@@ -271,6 +271,54 @@ defmodule MvWeb.MemberLive.Index.DateFilter do
     end
   end
 
+  @doc """
+  DB-side equivalent of the custom-date portion of `apply_in_memory/3`.
+
+  For each active custom-date filter, adds a predicate keeping members that have
+  a stored date value for the field within the inclusive `[from, to]` bounds.
+  The value is read from the JSONB union (`value->>'type' = 'date'`, then
+  `(value->>'value')::date`). Members without a date value row for the field are
+  excluded, mirroring the in-memory behaviour exactly.
+  """
+  @spec apply_custom_date_ash_filter(Ash.Query.t(), map(), [map()]) :: Ash.Query.t()
+  def apply_custom_date_ash_filter(%Ash.Query{} = query, filters, date_custom_fields)
+      when is_map(filters) and is_list(date_custom_fields) do
+    filters
+    |> active_custom_date_filters(date_custom_fields)
+    |> Enum.reduce(query, fn {id, bounds}, q -> apply_one_custom_date_filter(q, id, bounds) end)
+  end
+
+  defp apply_one_custom_date_filter(query, id, %{from: from, to: to}) do
+    case Ecto.UUID.cast(id) do
+      {:ok, uuid} -> filter_custom_date(query, uuid, from, to)
+      _ -> query
+    end
+  end
+
+  defp filter_custom_date(query, uuid, from, to) do
+    Ash.Query.filter(
+      query,
+      expr(
+        exists(
+          custom_field_values,
+          custom_field_id == ^uuid and
+            fragment("?->>'type' = 'date'", value) and
+            ^custom_date_bounds(from, to)
+        )
+      )
+    )
+  end
+
+  defp custom_date_bounds(nil, to), do: expr(fragment("(?->>'value')::date <= ?", value, ^to))
+  defp custom_date_bounds(from, nil), do: expr(fragment("(?->>'value')::date >= ?", value, ^from))
+
+  defp custom_date_bounds(from, to) do
+    expr(
+      fragment("(?->>'value')::date >= ?", value, ^from) and
+        fragment("(?->>'value')::date <= ?", value, ^to)
+    )
+  end
+
   @doc """
   Returns the UUID string keys of `filters` that name an active (at-least-one-
   bound-set) custom date field. The UUID must appear in `date_custom_fields`

lib/mv_web/live/member_live/index/overview_query.ex

@@ -18,6 +18,7 @@ defmodule MvWeb.MemberLive.Index.OverviewQuery do
   alias MvWeb.MemberLive.Index.DateFilter
 
   require Ash.Query
+  require Ash.Sort
 
   @type opts :: %{optional(atom()) => term()}
 
@@ -40,13 +41,18 @@ defmodule MvWeb.MemberLive.Index.OverviewQuery do
     |> apply_search(opts[:search])
     |> apply_group_filters(opts[:group_filters], opts[:groups])
     |> apply_fee_type_filters(opts[:fee_type_filters], opts[:fee_types])
+    |> apply_boolean_custom_field_filters(
+      opts[:boolean_custom_field_filters],
+      opts[:boolean_custom_fields]
+    )
     |> apply_date_filters(opts[:date_filters])
+    |> apply_custom_date_filters(opts[:date_filters], opts[:date_custom_fields])
     |> apply_cycle_status_filter(
       opts[:cycle_status_filter],
       opts[:show_current_cycle],
       today(opts)
     )
-    |> apply_sort(opts[:sort_field], opts[:sort_order])
+    |> apply_sort(opts[:sort_field], opts[:sort_order], opts[:custom_fields] || [])
   end
 
   defp today(opts), do: opts[:today] || Date.utc_today()
@@ -135,6 +141,48 @@ defmodule MvWeb.MemberLive.Index.OverviewQuery do
     end)
   end
 
+  # ---------------------------------------------------------------------------
+  # Boolean custom-field filters (AND across selected fields)
+  #
+  # Mirrors the previous in-memory behaviour: a member matches a `{field => bool}`
+  # filter only if it has a stored value row for that field whose boolean value
+  # equals `bool`. A member with no value row is excluded. Uses a JSONB
+  # containment predicate (`value @> '{"value": <bool>}'`), which the GIN index on
+  # `custom_field_values.value` can serve.
+  # ---------------------------------------------------------------------------
+
+  defp apply_boolean_custom_field_filters(query, filters, _boolean_fields)
+       when filters in [nil, %{}],
+       do: query
+
+  defp apply_boolean_custom_field_filters(query, filters, boolean_fields) do
+    valid_ids = valid_id_set(boolean_fields)
+
+    filters
+    |> Enum.filter(fn {id_str, _} -> MapSet.member?(valid_ids, id_str) end)
+    |> Enum.reduce(query, fn {id_str, bool}, q ->
+      case Ecto.UUID.cast(id_str) do
+        {:ok, uuid} -> apply_one_boolean_filter(q, uuid, bool)
+        _ -> q
+      end
+    end)
+  end
+
+  defp apply_one_boolean_filter(query, uuid, bool) when is_boolean(bool) do
+    Ash.Query.filter(
+      query,
+      expr(
+        exists(
+          custom_field_values,
+          custom_field_id == ^uuid and
+            fragment("? @> jsonb_build_object('value', ?::boolean)", value, ^bool)
+        )
+      )
+    )
+  end
+
+  defp apply_one_boolean_filter(query, _uuid, _bool), do: query
+
   # ---------------------------------------------------------------------------
   # Cycle-status filter (paid/unpaid, current or last-completed cycle)
   #
@@ -193,20 +241,99 @@ defmodule MvWeb.MemberLive.Index.OverviewQuery do
   defp apply_date_filters(query, filters) when is_map(filters),
     do: DateFilter.apply_ash_filter(query, filters)
 
+  defp apply_custom_date_filters(query, filters, custom_fields)
+       when is_map(filters) and is_list(custom_fields),
+       do: DateFilter.apply_custom_date_ash_filter(query, filters, custom_fields)
+
+  defp apply_custom_date_filters(query, _filters, _custom_fields), do: query
+
   # ---------------------------------------------------------------------------
   # Sort (always append the unique id tie-breaker for keyset stability)
   # ---------------------------------------------------------------------------
 
-  defp apply_sort(query, nil, _order), do: Ash.Query.sort(query, id: :asc)
+  defp apply_sort(query, nil, _order, _custom_fields), do: Ash.Query.sort(query, id: :asc)
-  defp apply_sort(query, _field, nil), do: Ash.Query.sort(query, id: :asc)
+  defp apply_sort(query, _field, nil, _custom_fields), do: Ash.Query.sort(query, id: :asc)
 
-  defp apply_sort(query, field, order) do
+  defp apply_sort(query, field, order, custom_fields) do
     case sort_key(field) do
-      nil -> Ash.Query.sort(query, id: :asc)
+      nil -> apply_custom_field_sort(query, field, order, custom_fields)
       key -> Ash.Query.sort(query, [{key, order}, {:id, :asc}])
     end
   end
 
+  # Sorts by a custom field's JSONB value DB-side. The value is read from the
+  # first matching `custom_field_values` row for the field, cast per the field's
+  # value type so integers sort numerically and dates chronologically. Empty
+  # strings and members without a value row sort last in both directions
+  # (NULLS LAST), mirroring the previous in-memory `CustomFieldSort` behaviour.
+  defp apply_custom_field_sort(query, field, order, custom_fields) do
+    with id_str when is_binary(id_str) <- custom_field_id(field),
+         %{} = cf <- Enum.find(custom_fields, &(to_string(&1.id) == id_str)) do
+      nils_order = if order == :desc, do: :desc_nils_last, else: :asc_nils_last
+
+      Ash.Query.sort(query, [
+        {custom_field_sort_calc(cf.value_type, cf.id), nils_order},
+        {:id, :asc}
+      ])
+    else
+      _ -> Ash.Query.sort(query, id: :asc)
+    end
+  end
+
+  defp custom_field_id(field) when is_atom(field), do: custom_field_id(Atom.to_string(field))
+
+  defp custom_field_id(field) when is_binary(field) do
+    case String.split(field, Mv.Constants.custom_field_prefix()) do
+      ["", id_str] -> id_str
+      _ -> nil
+    end
+  end
+
+  defp custom_field_id(_), do: nil
+
+  # Maps the field's value type to the first matching custom-field value's typed
+  # sort key (scoped to the field), backed by the `sort_*` calculations on
+  # `CustomFieldValue` (a raw fragment is not allowed as an aggregate `field:`).
+  defp custom_field_sort_calc(:integer, id),
+    do:
+      Ash.Sort.expr_sort(
+        first(custom_field_values,
+          field: :sort_numeric,
+          query: [filter: expr(custom_field_id == ^id)]
+        ),
+        :decimal
+      )
+
+  defp custom_field_sort_calc(:date, id),
+    do:
+      Ash.Sort.expr_sort(
+        first(custom_field_values,
+          field: :sort_date,
+          query: [filter: expr(custom_field_id == ^id)]
+        ),
+        :date
+      )
+
+  defp custom_field_sort_calc(:boolean, id),
+    do:
+      Ash.Sort.expr_sort(
+        first(custom_field_values,
+          field: :sort_boolean,
+          query: [filter: expr(custom_field_id == ^id)]
+        ),
+        :boolean
+      )
+
+  defp custom_field_sort_calc(_type, id),
+    do:
+      Ash.Sort.expr_sort(
+        first(custom_field_values,
+          field: :sort_text,
+          query: [filter: expr(custom_field_id == ^id)]
+        ),
+        :string
+      )
+
   # Resolves a sort field (atom or string) to a DB sort key, or nil if it is a
   # computed field handled elsewhere / not sortable.
   defp sort_key(field) when field in [:membership_fee_type, "membership_fee_type"],

priv/repo/migrations/20260630170637_add_custom_field_values_value_gin_index.exs

@@ -0,0 +1,21 @@
+defmodule Mv.Repo.Migrations.AddCustomFieldValuesValueGinIndex do
+  @moduledoc """
+  Adds a GIN index on `custom_field_values.value` (JSONB) to serve the boolean
+  custom-field containment predicates used by the member overview.
+  """
+
+  use Ecto.Migration
+
+  def up do
+    create index(:custom_field_values, ["value"],
+             name: "custom_field_values_value_gin_index",
+             using: "gin"
+           )
+  end
+
+  def down do
+    drop_if_exists index(:custom_field_values, ["value"],
+                     name: "custom_field_values_value_gin_index"
+                   )
+  end
+end

priv/resource_snapshots/repo/custom_field_values/20260630170638.json

@@ -0,0 +1,148 @@
+{
+  "attributes": [
+    {
+      "allow_nil?": false,
+      "default": "fragment(\"gen_random_uuid()\")",
+      "generated?": false,
+      "precision": null,
+      "primary_key?": true,
+      "references": null,
+      "scale": null,
+      "size": null,
+      "source": "id",
+      "type": "uuid"
+    },
+    {
+      "allow_nil?": true,
+      "default": "nil",
+      "generated?": false,
+      "precision": null,
+      "primary_key?": false,
+      "references": null,
+      "scale": null,
+      "size": null,
+      "source": "value",
+      "type": "map"
+    },
+    {
+      "allow_nil?": true,
+      "default": "nil",
+      "generated?": false,
+      "precision": null,
+      "primary_key?": false,
+      "references": {
+        "deferrable": false,
+        "destination_attribute": "id",
+        "destination_attribute_default": null,
+        "destination_attribute_generated": null,
+        "index?": false,
+        "match_type": null,
+        "match_with": null,
+        "multitenancy": {
+          "attribute": null,
+          "global": null,
+          "strategy": null
+        },
+        "name": "custom_field_values_member_id_fkey",
+        "on_delete": "delete",
+        "on_update": null,
+        "primary_key?": true,
+        "schema": "public",
+        "table": "members"
+      },
+      "scale": null,
+      "size": null,
+      "source": "member_id",
+      "type": "uuid"
+    },
+    {
+      "allow_nil?": true,
+      "default": "nil",
+      "generated?": false,
+      "precision": null,
+      "primary_key?": false,
+      "references": {
+        "deferrable": false,
+        "destination_attribute": "id",
+        "destination_attribute_default": null,
+        "destination_attribute_generated": null,
+        "index?": false,
+        "match_type": null,
+        "match_with": null,
+        "multitenancy": {
+          "attribute": null,
+          "global": null,
+          "strategy": null
+        },
+        "name": "custom_field_values_custom_field_id_fkey",
+        "on_delete": "delete",
+        "on_update": null,
+        "primary_key?": true,
+        "schema": "public",
+        "table": "custom_fields"
+      },
+      "scale": null,
+      "size": null,
+      "source": "custom_field_id",
+      "type": "uuid"
+    }
+  ],
+  "base_filter": null,
+  "check_constraints": [],
+  "create_table_options": null,
+  "custom_indexes": [
+    {
+      "all_tenants?": false,
+      "concurrently": false,
+      "error_fields": [
+        "value"
+      ],
+      "fields": [
+        {
+          "type": "string",
+          "value": "value"
+        }
+      ],
+      "include": null,
+      "message": null,
+      "name": "custom_field_values_value_gin_index",
+      "nulls_distinct": true,
+      "prefix": null,
+      "table": null,
+      "unique": false,
+      "using": "gin",
+      "where": null
+    }
+  ],
+  "custom_statements": [],
+  "has_create_action": true,
+  "hash": "6B19604F0AA26F503094E6AF5086FDAE0D054096B24099376EFF4BBCFF7E3CB5",
+  "identities": [
+    {
+      "all_tenants?": false,
+      "base_filter": null,
+      "index_name": "custom_field_values_unique_custom_field_per_member_index",
+      "keys": [
+        {
+          "type": "atom",
+          "value": "member_id"
+        },
+        {
+          "type": "atom",
+          "value": "custom_field_id"
+        }
+      ],
+      "name": "unique_custom_field_per_member",
+      "nils_distinct?": true,
+      "where": null
+    }
+  ],
+  "multitenancy": {
+    "attribute": null,
+    "global": null,
+    "strategy": null
+  },
+  "repo": "Elixir.Mv.Repo",
+  "schema": null,
+  "table": "custom_field_values"
+}

test/mv_web/member_live/index_boolean_custom_field_filter_test.exs

@@ -0,0 +1,83 @@
+defmodule MvWeb.MemberLive.IndexBooleanCustomFieldFilterTest do
+  @moduledoc """
+  §1.15 — DB-backed boolean custom-field filter (in/not_in) must match the
+  previous in-memory behaviour exactly, including a member with no stored value
+  row for the field.
+  """
+  use Mv.DataCase, async: false
+
+  import Mv.Fixtures, only: [member_fixture_with_actor: 2]
+
+  alias Mv.Membership.CustomField
+  alias Mv.Membership.CustomFieldValue
+  alias Mv.Membership.Member
+  alias MvWeb.MemberLive.Index
+  alias MvWeb.MemberLive.Index.OverviewQuery
+
+  setup do
+    actor = Mv.Helpers.SystemActor.get_system_actor()
+
+    {:ok, field} =
+      CustomField
+      |> Ash.Changeset.for_create(:create, %{
+        name: "newsletter_#{System.unique_integer([:positive])}",
+        value_type: :boolean,
+        show_in_overview: true
+      })
+      |> Ash.create(actor: actor)
+
+    yes = member_fixture_with_actor(%{}, actor)
+    no = member_fixture_with_actor(%{}, actor)
+    none = member_fixture_with_actor(%{}, actor)
+
+    set_bool(yes, field, true, actor)
+    set_bool(no, field, false, actor)
+
+    %{actor: actor, field: field, yes: yes, no: no, none: none}
+  end
+
+  defp set_bool(member, field, bool, actor) do
+    CustomFieldValue
+    |> Ash.Changeset.for_create(:create, %{
+      member_id: member.id,
+      custom_field_id: field.id,
+      value: %{"_union_type" => "boolean", "_union_value" => bool}
+    })
+    |> Ash.create!(actor: actor)
+  end
+
+  defp db_ids(filters, field, actor) do
+    OverviewQuery.build(%{
+      boolean_custom_field_filters: filters,
+      boolean_custom_fields: [field]
+    })
+    |> Ash.read!(actor: actor)
+    |> MapSet.new(& &1.id)
+  end
+
+  defp oracle_ids(filters, field, actor) do
+    members =
+      Member
+      |> Ash.Query.load(custom_field_values: [:custom_field])
+      |> Ash.read!(actor: actor)
+
+    Index.apply_boolean_custom_field_filters(members, filters, [field])
+    |> MapSet.new(& &1.id)
+  end
+
+  test "filter true matches only members with stored true value", ctx do
+    filters = %{to_string(ctx.field.id) => true}
+    assert db_ids(filters, ctx.field, ctx.actor) == oracle_ids(filters, ctx.field, ctx.actor)
+    assert ctx.yes.id in db_ids(filters, ctx.field, ctx.actor)
+    refute ctx.no.id in db_ids(filters, ctx.field, ctx.actor)
+    refute ctx.none.id in db_ids(filters, ctx.field, ctx.actor)
+  end
+
+  test "filter false matches only members with stored false value (not missing rows)", ctx do
+    filters = %{to_string(ctx.field.id) => false}
+    assert db_ids(filters, ctx.field, ctx.actor) == oracle_ids(filters, ctx.field, ctx.actor)
+    assert ctx.no.id in db_ids(filters, ctx.field, ctx.actor)
+    refute ctx.yes.id in db_ids(filters, ctx.field, ctx.actor)
+    refute ctx.none.id in db_ids(filters, ctx.field, ctx.actor)
+  end
+end

test/mv_web/member_live/index_date_custom_field_filter_test.exs

@@ -0,0 +1,91 @@
+defmodule MvWeb.MemberLive.IndexDateCustomFieldFilterTest do
+  @moduledoc """
+  §1.16 — DB-backed date custom-field range filter must match the previous
+  in-memory behaviour exactly, including inclusive boundaries and members with
+  no stored value row (excluded).
+  """
+  use Mv.DataCase, async: false
+
+  import Mv.Fixtures, only: [member_fixture_with_actor: 2]
+
+  alias Mv.Membership.CustomField
+  alias Mv.Membership.CustomFieldValue
+  alias Mv.Membership.Member
+  alias MvWeb.MemberLive.Index.DateFilter
+  alias MvWeb.MemberLive.Index.OverviewQuery
+
+  setup do
+    actor = Mv.Helpers.SystemActor.get_system_actor()
+
+    {:ok, field} =
+      CustomField
+      |> Ash.Changeset.for_create(:create, %{
+        name: "birthday_#{System.unique_integer([:positive])}",
+        value_type: :date,
+        show_in_overview: true
+      })
+      |> Ash.create(actor: actor)
+
+    on_lower = member_with_date(field, ~D[2024-01-01], actor)
+    inside = member_with_date(field, ~D[2024-06-15], actor)
+    on_upper = member_with_date(field, ~D[2024-12-31], actor)
+    below = member_with_date(field, ~D[2023-12-31], actor)
+    above = member_with_date(field, ~D[2025-01-01], actor)
+    none = member_fixture_with_actor(%{}, actor)
+
+    %{
+      actor: actor,
+      field: field,
+      on_lower: on_lower,
+      inside: inside,
+      on_upper: on_upper,
+      below: below,
+      above: above,
+      none: none
+    }
+  end
+
+  defp member_with_date(field, date, actor) do
+    member = member_fixture_with_actor(%{}, actor)
+
+    CustomFieldValue
+    |> Ash.Changeset.for_create(:create, %{
+      member_id: member.id,
+      custom_field_id: field.id,
+      value: %{"_union_type" => "date", "_union_value" => date}
+    })
+    |> Ash.create!(actor: actor)
+
+    member
+  end
+
+  defp filters(field), do: %{to_string(field.id) => %{from: ~D[2024-01-01], to: ~D[2024-12-31]}}
+
+  defp db_ids(field, actor) do
+    OverviewQuery.build(%{date_filters: filters(field), date_custom_fields: [field]})
+    |> Ash.read!(actor: actor)
+    |> MapSet.new(& &1.id)
+  end
+
+  defp oracle_ids(field, actor) do
+    members =
+      Member
+      |> Ash.Query.load(custom_field_values: [:custom_field])
+      |> Ash.read!(actor: actor)
+
+    DateFilter.apply_in_memory(members, filters(field), [field])
+    |> MapSet.new(& &1.id)
+  end
+
+  test "inclusive range matches in-memory oracle, boundaries included", ctx do
+    db = db_ids(ctx.field, ctx.actor)
+    assert db == oracle_ids(ctx.field, ctx.actor)
+
+    assert ctx.on_lower.id in db
+    assert ctx.inside.id in db
+    assert ctx.on_upper.id in db
+    refute ctx.below.id in db
+    refute ctx.above.id in db
+    refute ctx.none.id in db
+  end
+end

test/mv_web/member_live/index_filter_parity_property_test.exs

@@ -0,0 +1,245 @@
+defmodule MvWeb.MemberLive.IndexFilterParityPropertyTest do
+  @moduledoc """
+  §2.1 — Filter result-set parity.
+
+  For generated member populations × filter-parameter combinations, the set of
+  member ids returned by the DB-backed `:overview` query equals the set returned
+  by the previous in-memory implementation (the reference oracle).
+
+  The unchanged DB filters (group, fee-type) are applied identically in both
+  arms; the property isolates the filters that moved from memory to the DB
+  (boolean custom fields, date custom fields, paid/unpaid cycle status) by
+  applying them DB-side in one arm and in-memory in the other.
+  """
+  use Mv.DataCase, async: false
+  use ExUnitProperties
+
+  import Mv.Fixtures, only: [create_fee_type: 2, member_fixture_with_actor: 2, create_cycle: 4]
+
+  alias Mv.Membership.CustomField
+  alias Mv.Membership.CustomFieldValue
+  alias Mv.Membership.Member
+  alias MvWeb.MemberLive.Index
+  alias MvWeb.MemberLive.Index.DateFilter
+  alias MvWeb.MemberLive.Index.MembershipFeeStatus
+  alias MvWeb.MemberLive.Index.OverviewQuery
+
+  @today ~D[2024-07-15]
+  @cycle_starts [~D[2023-01-01], ~D[2024-01-01], ~D[2025-01-01]]
+  @date_values [~D[2023-06-01], ~D[2024-06-15], ~D[2025-06-01]]
+
+  setup do
+    actor = Mv.Helpers.SystemActor.get_system_actor()
+    ft1 = create_fee_type(%{interval: :yearly}, actor)
+    ft2 = create_fee_type(%{interval: :yearly}, actor)
+
+    {:ok, bool_cf} =
+      CustomField
+      |> Ash.Changeset.for_create(:create, %{
+        name: "flag_#{System.unique_integer([:positive])}",
+        value_type: :boolean,
+        show_in_overview: true
+      })
+      |> Ash.create(actor: actor)
+
+    {:ok, date_cf} =
+      CustomField
+      |> Ash.Changeset.for_create(:create, %{
+        name: "dt_#{System.unique_integer([:positive])}",
+        value_type: :date,
+        show_in_overview: true
+      })
+      |> Ash.create(actor: actor)
+
+    %{actor: actor, ft1: ft1, ft2: ft2, bool_cf: bool_cf, date_cf: date_cf}
+  end
+
+  # ----- generators ---------------------------------------------------------
+
+  defp status_gen, do: StreamData.member_of([:unpaid, :paid, :suspended])
+
+  defp member_spec_gen do
+    StreamData.fixed_map(%{
+      fee_type: StreamData.member_of([:ft1, :ft2]),
+      cycles:
+        StreamData.list_of(
+          StreamData.tuple({StreamData.member_of(@cycle_starts), status_gen()}),
+          max_length: 3
+        ),
+      bool: StreamData.member_of([:none, true, false]),
+      date: StreamData.member_of([:none | @date_values]),
+      in_group: StreamData.boolean()
+    })
+  end
+
+  defp filter_params_gen do
+    StreamData.fixed_map(%{
+      cycle_status: StreamData.member_of([nil, :paid, :unpaid]),
+      show_current: StreamData.boolean(),
+      bool: StreamData.member_of([nil, true, false]),
+      date_range: StreamData.member_of([nil, {~D[2024-01-01], ~D[2024-12-31]}]),
+      group: StreamData.member_of([nil, :in, :not_in]),
+      fee_type: StreamData.member_of([nil, :in, :not_in])
+    })
+  end
+
+  # ----- helpers ------------------------------------------------------------
+
+  defp clear_members(actor) do
+    Member |> Ash.read!(actor: actor) |> Enum.each(&Ash.destroy!(&1, actor: actor))
+  end
+
+  defp create_population(specs, ctx) do
+    Enum.map(specs, fn spec ->
+      ft = if spec.fee_type == :ft1, do: ctx.ft1, else: ctx.ft2
+      member = member_fixture_with_actor(%{membership_fee_type_id: ft.id}, ctx.actor)
+
+      spec.cycles
+      |> Enum.uniq_by(fn {start, _} -> start end)
+      |> Enum.each(fn {start, status} ->
+        create_cycle(member, ft, %{cycle_start: start, status: status}, ctx.actor)
+      end)
+
+      maybe_set_value(member, ctx.bool_cf, spec.bool, "boolean", ctx.actor)
+      maybe_set_value(member, ctx.date_cf, spec.date, "date", ctx.actor)
+
+      if spec.in_group, do: add_to_group(member, ctx, ctx.actor)
+      {member.id, spec}
+    end)
+  end
+
+  defp maybe_set_value(_member, _cf, :none, _type, _actor), do: :ok
+
+  defp maybe_set_value(member, cf, value, type, actor) do
+    CustomFieldValue
+    |> Ash.Changeset.for_create(:create, %{
+      member_id: member.id,
+      custom_field_id: cf.id,
+      value: %{"_union_type" => type, "_union_value" => value}
+    })
+    |> Ash.create!(actor: actor)
+  end
+
+  defp add_to_group(member, ctx, actor) do
+    Mv.Membership.create_member_group(%{member_id: member.id, group_id: ctx.group.id},
+      actor: actor
+    )
+  end
+
+  defp base_opts(params, ctx) do
+    %{}
+    |> put_group(params.group, ctx)
+    |> put_fee_type(params.fee_type, ctx)
+  end
+
+  defp put_group(opts, nil, _ctx), do: opts
+
+  defp put_group(opts, dir, ctx),
+    do: Map.merge(opts, %{group_filters: %{to_string(ctx.group.id) => dir}, groups: [ctx.group]})
+
+  defp put_fee_type(opts, nil, _ctx), do: opts
+
+  defp put_fee_type(opts, dir, ctx),
+    do:
+      Map.merge(opts, %{fee_type_filters: %{to_string(ctx.ft1.id) => dir}, fee_types: [ctx.ft1]})
+
+  defp moved_opts(params, ctx) do
+    %{today: @today}
+    |> put_cycle(params.cycle_status, params.show_current)
+    |> put_bool(params.bool, ctx)
+    |> put_date(params.date_range, ctx)
+  end
+
+  defp put_cycle(opts, nil, _show), do: opts
+
+  defp put_cycle(opts, status, show),
+    do: Map.merge(opts, %{cycle_status_filter: status, show_current_cycle: show})
+
+  defp put_bool(opts, nil, _ctx), do: opts
+
+  defp put_bool(opts, bool, ctx),
+    do:
+      Map.merge(opts, %{
+        boolean_custom_field_filters: %{to_string(ctx.bool_cf.id) => bool},
+        boolean_custom_fields: [ctx.bool_cf]
+      })
+
+  defp put_date(opts, nil, _ctx), do: opts
+
+  defp put_date(opts, {from, to}, ctx),
+    do:
+      Map.merge(opts, %{
+        date_filters: %{to_string(ctx.date_cf.id) => %{from: from, to: to}},
+        date_custom_fields: [ctx.date_cf]
+      })
+
+  defp db_ids(params, ctx) do
+    base_opts(params, ctx)
+    |> Map.merge(moved_opts(params, ctx))
+    |> OverviewQuery.build()
+    |> Ash.read!(actor: ctx.actor)
+    |> MapSet.new(& &1.id)
+  end
+
+  defp oracle_ids(params, ctx) do
+    base_members =
+      base_opts(params, ctx)
+      |> OverviewQuery.build()
+      |> Ash.Query.load([
+        :membership_fee_type,
+        {:custom_field_values, [:custom_field]},
+        {:membership_fee_cycles, [:membership_fee_type]}
+      ])
+      |> Ash.read!(actor: ctx.actor)
+
+    base_members
+    |> apply_oracle_bool(params, ctx)
+    |> apply_oracle_date(params, ctx)
+    |> apply_oracle_cycle(params)
+    |> MapSet.new(& &1.id)
+  end
+
+  defp apply_oracle_bool(members, %{bool: nil}, _ctx), do: members
+
+  defp apply_oracle_bool(members, %{bool: bool}, ctx) do
+    Index.apply_boolean_custom_field_filters(
+      members,
+      %{to_string(ctx.bool_cf.id) => bool},
+      [ctx.bool_cf]
+    )
+  end
+
+  defp apply_oracle_date(members, %{date_range: nil}, _ctx), do: members
+
+  defp apply_oracle_date(members, %{date_range: {from, to}}, ctx) do
+    DateFilter.apply_in_memory(
+      members,
+      %{to_string(ctx.date_cf.id) => %{from: from, to: to}},
+      [ctx.date_cf]
+    )
+  end
+
+  defp apply_oracle_cycle(members, %{cycle_status: nil}), do: members
+
+  defp apply_oracle_cycle(members, %{cycle_status: status, show_current: show}) do
+    Enum.filter(members, fn m ->
+      MembershipFeeStatus.get_cycle_status_for_member(m, show, @today) == status
+    end)
+  end
+
+  property "DB-backed filter result set equals the in-memory oracle", ctx do
+    check all(
+            specs <- StreamData.list_of(member_spec_gen(), min_length: 1, max_length: 5),
+            params <- filter_params_gen(),
+            max_runs: 30
+          ) do
+      clear_members(ctx.actor)
+      group = Mv.Fixtures.group_fixture(%{name: "G#{System.unique_integer([:positive])}"})
+      ctx = Map.put(ctx, :group, group)
+
+      _population = create_population(specs, ctx)
+
+      assert db_ids(params, ctx) == oracle_ids(params, ctx)
+    end
+  end
+end

test/mv_web/member_live/index_overview_query_sort_test.exs

@@ -0,0 +1,98 @@
+defmodule MvWeb.MemberLive.IndexOverviewQuerySortTest do
+  @moduledoc """
+  §2.3 — Sort determinism for custom-field sorts pushed to the DB.
+
+  The keyset property test covers standard fields; these examples pin the
+  type-aware custom-field ordering (numeric vs lexical, chronological dates) and
+  the NULLS-LAST behaviour for missing/empty values in both directions, which
+  the previous in-memory `CustomFieldSort` guaranteed.
+  """
+  use Mv.DataCase, async: false
+
+  import Mv.Fixtures, only: [member_fixture_with_actor: 2]
+
+  alias Mv.Membership.CustomField
+  alias Mv.Membership.CustomFieldValue
+  alias MvWeb.MemberLive.Index.OverviewQuery
+
+  setup do
+    %{actor: Mv.Helpers.SystemActor.get_system_actor()}
+  end
+
+  defp clear_members(actor) do
+    Mv.Membership.Member |> Ash.read!(actor: actor) |> Enum.each(&Ash.destroy!(&1, actor: actor))
+  end
+
+  defp create_field(value_type, actor) do
+    {:ok, field} =
+      CustomField
+      |> Ash.Changeset.for_create(:create, %{
+        name: "sort_#{value_type}_#{System.unique_integer([:positive])}",
+        value_type: value_type,
+        show_in_overview: true
+      })
+      |> Ash.create(actor: actor)
+
+    field
+  end
+
+  defp set_value(member, field, union_type, union_value, actor) do
+    {:ok, _} =
+      CustomFieldValue
+      |> Ash.Changeset.for_create(:create, %{
+        member_id: member.id,
+        custom_field_id: field.id,
+        value: %{"_union_type" => union_type, "_union_value" => union_value}
+      })
+      |> Ash.create(actor: actor)
+  end
+
+  defp sorted_ids(field, order, actor) do
+    OverviewQuery.build(%{
+      sort_field: "custom_field_#{field.id}",
+      sort_order: order,
+      custom_fields: [field]
+    })
+    |> Ash.read!(actor: actor, page: [limit: 100])
+    |> then(& &1.results)
+    |> Enum.map(& &1.id)
+  end
+
+  test "integer custom field sorts numerically, missing value last in both directions", %{
+    actor: actor
+  } do
+    clear_members(actor)
+    field = create_field(:integer, actor)
+    a = member_fixture_with_actor(%{first_name: "A"}, actor)
+    b = member_fixture_with_actor(%{first_name: "B"}, actor)
+    none = member_fixture_with_actor(%{first_name: "N"}, actor)
+    # 9 vs 10: lexical order would place "10" before "9"; numeric must not.
+    set_value(a, field, "integer", 10, actor)
+    set_value(b, field, "integer", 9, actor)
+
+    assert sorted_ids(field, :asc, actor) == [b.id, a.id, none.id]
+    assert sorted_ids(field, :desc, actor) == [a.id, b.id, none.id]
+  end
+
+  test "date custom field sorts chronologically", %{actor: actor} do
+    clear_members(actor)
+    field = create_field(:date, actor)
+    older = member_fixture_with_actor(%{first_name: "Older"}, actor)
+    newer = member_fixture_with_actor(%{first_name: "Newer"}, actor)
+    set_value(older, field, "date", "1981-01-29", actor)
+    set_value(newer, field, "date", "1986-07-02", actor)
+
+    assert sorted_ids(field, :asc, actor) == [older.id, newer.id]
+  end
+
+  test "empty string value sorts last like a missing value", %{actor: actor} do
+    clear_members(actor)
+    field = create_field(:string, actor)
+    filled = member_fixture_with_actor(%{first_name: "Filled"}, actor)
+    empty = member_fixture_with_actor(%{first_name: "Empty"}, actor)
+    set_value(filled, field, "string", "AAA", actor)
+    set_value(empty, field, "string", "", actor)
+
+    assert sorted_ids(field, :asc, actor) == [filled.id, empty.id]
+  end
+end