WIP 20250516-1049

Author: jechol

.gitignore

@@ -21,3 +21,4 @@ ash_random_params-*.tar
 
 # Temporary files, for example, from tests.
 /tmp/
+*.code-workspace

lib/random/default_random.ex

@@ -41,6 +41,8 @@ defmodule AshRandomParams.DefaultRandom do
     tag_value = type_info |> Keyword.fetch!(:tag_value)
     attr_names = subtype |> Ash.Resource.Info.attributes() |> Enum.map(& &1.name)
 
+    # primary_create = subtype |> Ash.Resource.Info.primary_action(:create)
+
     subtype
     |> Ash.Changeset.for_create(:fac_rec, %{}, ash_opts)
     |> Ash.create!(ash_opts)
@@ -54,24 +56,42 @@ defmodule AshRandomParams.DefaultRandom do
     constraints |> Keyword.fetch!(:one_of) |> Enum.random()
   end
 
-  def random(%{type: Ash.Type.Integer}, _opts, _context), do: 123_456
-  def random(%{type: Ash.Type.Decimal}, _opts, _context), do: Decimal.new("123456.789")
+  def random(%{type: Ash.Type.Integer}, _opts, _context), do: random_int()
+
+  def random(%{type: Ash.Type.Decimal}, _opts, _context),
+    do: Decimal.new("#{random_int()}.#{random_int()}")
+
   def random(%{type: Ash.Type.Boolean}, _opts, _context), do: [true, false] |> Enum.random()
   def random(%{type: Ash.Type.Map}, _opts, _context), do: %{}
 
-  def random(%{type: Ash.Type.Date}, _opts, _context), do: Date.utc_today()
-  def random(%{type: Ash.Type.UtcDatetime}, _opts, _context), do: DateTime.utc_now()
-  def random(%{type: Ash.Type.UtcDatetimeUsec}, _opts, _context), do: DateTime.utc_now()
-  def random(%{type: Ash.Type.DateTime}, _opts, _context), do: DateTime.utc_now()
+  def random(%{type: Ash.Type.Date}, _opts, _context),
+    do: random_date_time() |> DateTime.to_date()
+
+  def random(%{type: Ash.Type.UtcDatetime}, _opts, _context), do: random_date_time()
+  def random(%{type: Ash.Type.UtcDatetimeUsec}, _opts, _context), do: random_date_time()
+  def random(%{type: Ash.Type.DateTime}, _opts, _context), do: random_date_time()
 
   def random(%{type: Ash.Type.String, name: name}, _opts, _context),
-    do: "#{name}-#{:rand.uniform(1_000_000_000_000)}"
+    do: "#{name}-#{random_int()}"
 
   def random(%{type: Ash.Type.CiString, name: name}, _opts, _context),
-    do: "#{name}-#{:rand.uniform(1_000_000_000_000)}"
+    do: "#{name}-#{random_int()}"
 
   def random(%{name: name, type: type} = attr_or_arg, opts, context) do
     {attr_or_arg, opts, context} |> dbg()
-    raise "Cannot make random value for #{name} of #{type}"
+    raise "Cannot make random value for name: #{name}, type: #{type}"
+  end
+
+  # Private
+
+  @year_seconds 365 * 24 * 60 * 60
+
+  defp random_date_time() do
+    DateTime.utc_now()
+    |> DateTime.add(:rand.uniform(20 * @year_seconds) - 10 * @year_seconds, :second)
+  end
+
+  defp random_int() do
+    :rand.uniform(1_000_000_000_000)
   end
 end

lib/transformer.ex

@@ -66,53 +66,70 @@ defmodule AshRandomParams.Transformer do
     init_keys = init_params |> Map.keys()
     union_keys = tagged_unions |> Map.values()
 
-    new_attrs =
-      Ash.Resource.Info.attributes(resource)
-      |> Enum.filter(&(&1.name in action.accept))
-      |> Enum.reject(&(&1.name in init_keys))
-      |> Enum.reject(&(&1.name in union_keys))
-      |> Enum.reject(&(&1.name in exclude))
-      |> Enum.reject(&(&1.allow_nil? and &1.name not in include))
-
-    belongs_to_names =
+    belongs_to_attrs =
       resource
       |> Ash.Resource.Info.relationships()
       |> Enum.flat_map(fn
-        %BelongsTo{name: name, source_attribute: src_attr} -> [name, src_attr]
+        %BelongsTo{source_attribute: src_attr} -> [src_attr]
         _ -> []
       end)
 
-    new_args =
-      action.arguments
-      |> Enum.reject(&(&1.name in belongs_to_names))
-      |> Enum.reject(&(&1.name in init_keys))
-      |> Enum.reject(&(&1.name in union_keys))
-      |> Enum.reject(&(&1.name in exclude))
-      |> Enum.reject(&(&1.allow_nil? and &1.name not in include))
-
-    new_params =
-      (new_attrs ++ new_args)
-      |> Map.new(fn %{name: name, default: default} = attr_or_arg ->
-        value =
-          case default do
-            nil ->
-              random_mod.random(attr_or_arg, random_opts, %{random: random, action_context: ctx})
-
-            default when is_function(default, 0) ->
-              default.()
-
-            default ->
-              default
-          end
-
-        {name, value}
-      end)
+    rel_names =
+      resource
+      |> Ash.Resource.Info.relationships()
+      |> Enum.map(& &1.name)
 
-    result_params =
-      (action.accept ++ Enum.map(action.arguments, & &1.name))
-      |> Map.new(fn name -> {name, nil} end)
-      |> Map.merge(init_params)
-      |> Map.merge(new_params)
+    accepted_attrs =
+      Ash.Resource.Info.attributes(resource)
+      |> Enum.filter(&(&1.name in action.accept))
+
+    candidates = accepted_attrs ++ action.arguments
+
+    placeholder =
+      candidates
+      |> then(fn attr_or_args ->
+        if action.type == :create do
+          attr_or_args
+        else
+          attr_or_args
+          |> Enum.reject(&(&1.name in rel_names))
+          |> Enum.reject(&(&1.name in belongs_to_attrs))
+        end
+      end)
+      |> Map.new(&{&1.name, nil})
+
+    generated_params =
+      (
+        fields_by_unfill =
+          candidates
+          |> Enum.reject(&(&1.name in rel_names))
+          |> Enum.reject(&(&1.name in belongs_to_attrs))
+          |> Enum.reject(&(&1.name in union_keys))
+          |> Enum.reject(&(&1.name in exclude))
+          |> Enum.reject(& &1.allow_nil?)
+
+        fields_by_fill = candidates |> Enum.filter(&(&1.name in include))
+
+        (fields_by_unfill ++ fields_by_fill)
+        |> Enum.reject(&(&1.name in init_keys))
+        |> Map.new(fn %{name: name, default: default} = attr_or_arg ->
+          value =
+            case default do
+              nil ->
+                random_mod.random(attr_or_arg, random_opts, %{random: random, action_context: ctx})
+
+              default when is_function(default, 0) ->
+                default.()
+
+              default ->
+                default
+            end
+
+          {name, value}
+        end)
+      )
+
+    result_params = placeholder |> Map.merge(init_params) |> Map.merge(generated_params)
 
     union_params =
       tagged_unions

test/ash_random_params_test.exs

@@ -1,7 +1,7 @@
 defmodule AshRandomParamsTest do
   use ExUnit.Case, async: true
 
-  alias __MODULE__.{Random, Post, Domain}
+  alias __MODULE__.{Random, Post, Author, Domain}
 
   defmodule Post do
     use Ash.Resource, domain: Domain, data_layer: Ash.DataLayer.Ets, extensions: [AshRandomParams]
@@ -24,11 +24,35 @@ defmodule AshRandomParamsTest do
       defaults [:read, :destroy, create: :*, update: :*]
     end
 
+    relationships do
+      belongs_to :author, Author, allow_nil?: false, public?: true
+    end
+
     random_params do
       random Random
     end
   end
 
+  defmodule Author do
+    use Ash.Resource, domain: Domain, data_layer: Ash.DataLayer.Ets
+
+    ets do
+      private? true
+    end
+
+    attributes do
+      uuid_primary_key :id
+    end
+
+    relationships do
+      has_many :posts, Post, public?: true
+    end
+
+    actions do
+      defaults [:read, :destroy, create: :*, update: :*]
+    end
+  end
+
   defmodule Random do
     use AshRandomParams.Random
 
@@ -48,93 +72,104 @@ defmodule AshRandomParamsTest do
 
     resources do
       resource Post
+      resource Author
     end
   end
 
   test "with no options" do
-    assert {:ok, ret} =
+    assert %{
+             author_id: nil,
+             req_str: "req_str-" <> _,
+             opt_str: nil,
+             req_int: 777,
+             opt_int: nil
+           } =
+             params =
              Post
              |> Ash.ActionInput.for_action(
                :random_params,
                %{
                  action: :create
                }
              )
-             |> Ash.run_action()
+             |> Ash.run_action!()
 
-    assert ret.req_str |> String.starts_with?("req_str-")
-    assert ret.opt_str == nil
-    assert ret.req_int == 777
-    assert ret.opt_int == nil
+    refute params |> Map.has_key?(:author)
   end
 
-  test "with init_params" do
-    assert {:ok, ret} =
-             Post
-             |> Ash.ActionInput.for_action(
-               :random_params,
-               %{
-                 action: :create,
-                 init_params: %{
-                   req_int: 123
+  describe "options" do
+    test "with init_params" do
+      assert %{
+               author_id: nil,
+               req_str: "req_str-" <> _,
+               opt_str: nil,
+               req_int: 123_456,
+               opt_int: nil
+             } =
+               Post
+               |> Ash.ActionInput.for_action(
+                 :random_params,
+                 %{
+                   action: :create,
+                   init_params: %{
+                     req_int: 123_456
+                   }
                  }
-               }
-             )
-             |> Ash.run_action()
-
-    assert ret.req_str |> String.starts_with?("req_str-")
-    assert ret.opt_str == nil
-    assert ret.req_int == 123
-    assert ret.opt_int == nil
-  end
-
-  test "with include" do
-    assert {:ok, ret} =
-             Post
-             |> Ash.ActionInput.for_action(
-               :random_params,
-               %{
-                 action: :create,
-                 include: [:opt_str]
-               }
-             )
-             |> Ash.run_action()
-
-    assert ret.req_str |> String.starts_with?("req_str-")
-    assert ret.opt_str |> String.starts_with?("opt_str-")
-    assert ret.req_int == 777
-    assert ret.opt_int == nil
-  end
+               )
+               |> Ash.run_action!()
+    end
 
-  test "with exclude" do
-    assert {:ok, ret} =
-             Post
-             |> Ash.ActionInput.for_action(
-               :random_params,
-               %{
-                 action: :create,
-                 exclude: [:req_str]
-               }
-             )
-             |> Ash.run_action()
+    test "with include" do
+      assert %{
+               author_id: nil,
+               req_str: "req_str-" <> _,
+               opt_str: "opt_str-" <> _,
+               req_int: 777,
+               opt_int: nil
+             } =
+               Post
+               |> Ash.ActionInput.for_action(
+                 :random_params,
+                 %{
+                   action: :create,
+                   include: [:opt_str]
+                 }
+               )
+               |> Ash.run_action!()
+    end
 
-    assert ret.req_str == nil
-    assert ret.opt_str == nil
-    assert ret.req_int == 777
-    assert ret.opt_int == nil
+    test "with exclude" do
+      assert %{
+               author_id: nil,
+               req_str: nil,
+               opt_str: nil,
+               req_int: 777,
+               opt_int: nil
+             } =
+               Post
+               |> Ash.ActionInput.for_action(
+                 :random_params,
+                 %{
+                   action: :create,
+                   exclude: [:req_str]
+                 }
+               )
+               |> Ash.run_action!()
+    end
   end
 
   test "code interface" do
-    assert {:ok, ret} =
-             Post.random_params(
+    assert %{
+             author_id: nil,
+             req_str: "req_str-" <> _,
+             opt_str: "opt_str-" <> _,
+             req_int: 777,
+             opt_int: nil
+           } =
+             Post.random_params!(
                :create,
                %{},
                %{include: [:opt_str]}
              )
-
-    assert ret.req_str |> String.starts_with?("req_str-")
-    assert ret.opt_str |> String.starts_with?("opt_str-")
-    assert ret.req_int == 777
-    assert ret.opt_int == nil
   end
 end