fix: stabilize field order in Ash.Expr.determine_map_type/1 (#2679)

Iterating a literal map expr (e.g. `expr(%{a: id, b: name})`) produces
a `{Ash.Type.Map, fields: [...]}` whose field order depends on Erlang
map iteration, which for small flatmaps is driven by internal atom
term ordering and varies between BEAM loads. Downstream consumers
that render ordered output (e.g. ash_typescript codegen) see flaky,
shuffled results across compiles.

Sort the resulting fields by atom name before returning so the output
is stable across compiles. The contract is only "deterministic", not
"alphabetical forever" — consumers should not rely on the specific
order, only that it doesn't change.

Author: barnabasJ

lib/ash/expr/expr.ex

@@ -1728,7 +1728,10 @@ defmodule Ash.Expr do
       end)
       |> case do
         {:ok, fields} ->
-          {:ok, {Ash.Type.Map, [fields: Enum.reverse(fields)]}}
+          # Maps aren't ordered — sort by the atom's string name so the
+          # output is stable across compiles for codegen consumers.
+          stable_fields = Enum.sort_by(fields, fn {key, _} -> Atom.to_string(key) end)
+          {:ok, {Ash.Type.Map, [fields: stable_fields]}}
 
         :error ->
           :error

test/type/auto_type_test.exs

@@ -212,6 +212,10 @@ defmodule Ash.Test.Type.AutoTypeTest do
       # map literal
       calculate :card, :auto, expr(%{title: title, score: score, active: active}), public?: true
 
+      # map literal with source keys deliberately not in alphabetic order —
+      # used to assert deterministic (alphabetic-by-atom-name) field ordering.
+      calculate :ordered_card, :auto, expr(%{z: title, a: score, m: active}), public?: true
+
       # struct literal (Ash.Type - embedded resource)
       calculate :address_struct_calc,
                 :auto,
@@ -371,6 +375,16 @@ defmodule Ash.Test.Type.AutoTypeTest do
       assert Keyword.get(fields, :active)[:type] == Ash.Type.Boolean
     end
 
+    test "map literal produces deterministic (alphabetic) field order" do
+      # `:ordered_card` has source keys z, a, m — the test guards against
+      # relying on Erlang map iteration order for small flatmaps, which is
+      # driven by internal atom term ordering and varies between BEAM loads.
+      calc = Ash.Resource.Info.calculation(Post, :ordered_card)
+      fields = calc.constraints[:fields]
+
+      assert Keyword.keys(fields) == [:a, :m, :z]
+    end
+
     test "Ash.Type struct literal resolves to the type directly" do
       calc = Ash.Resource.Info.calculation(Post, :address_struct_calc)
       assert calc.type == Address