Extracted

Author: jechol

README.md

@@ -2,30 +2,20 @@
 
 A library that generates random parameters for Ash resource actions. It provides a convenient way to create random test data for your Ash resources by automatically generating random values for accepts and arguments.
 
-## Installation
-
-Add `ash_random_params` to your list of dependencies in `mix.exs`:
-
-```elixir
-def deps do
-  [
-    {:ash_random_params, "~> 0.2.0"}
-  ]
-end
-```
-
 ## Usage
 
 Add the `random_params` DSL to your Ash resource:
 
 ```elixir
-defmodule MyApp.Post do
+defmodule Post do
   use Ash.Resource, extensions: [AshRandomParams]
 
   attributes do
     uuid_primary_key :id
+    attribute :author, :string, allow_nil?: false
     attribute :title, :string, allow_nil?: false
     attribute :content, :string, allow_nil?: true
+    attribute :tag, :string, allow_nil?: false, default: "JS"
   end
 
   random_params do
@@ -34,6 +24,46 @@ defmodule MyApp.Post do
 end
 ```
 
+### Using Random Params
+
+```elixir
+# Basic usage
+Post.random_params!(:create)
+=> %{author: "author-81491", title: "title-388112", content: nil, tag: "JS"}
+
+# With initial params
+Post.random_params!(:create, %{author: "James"})
+=> %{author: "James", title: "title-388112", content: nil, tag: "JS"}
+
+# With options
+Post.random_params!(:create, %{author: "James"}, %{
+  populate: [:content],   
+  omit: [:title],   
+  include_defaults?: false
+})
+=> %{author: "James", content: "content-38128"}
+```
+
+### Default Behavior
+
+By default, it generates random values for attributes and arguments that have `allow_nil?: false` and no default value (`default == nil`). In the example above, `author` and `title` fall into this category.
+
+### Belongs To Relationships
+
+For attributes and arguments that match the `name` or `source_attribute` of a `belongs_to` relationship:
+- In `create` actions, they are generated with `nil` values
+- In other actions, they are not generated at all
+
+This behavior exists because:
+- In `create` actions, omitting a value is equivalent to setting it to `nil`
+- In `update` actions, omitting a value preserves the existing relationship, while explicitly setting it to `nil` removes the relationship
+
+### Options
+
+- `populate`: Forces generation of random values for specified attributes/arguments, overriding the default behavior
+- `omit`: Prevents generation of random values for specified attributes/arguments, overriding the default behavior
+- `include_defaults?`: When set to `true`, includes default values for attributes/arguments that have either `allow_nil?: true` or a non-nil default value. Defaults to `true`. In the example above, this would add `%{content: nil, tag: "JS"}` to the generated params.
+
 ### Custom Random Generator
 
 You can implement a custom random generator by using the `AshRandomParams.Random` behaviour:
@@ -44,7 +74,7 @@ defmodule MyRandom do
 
   @impl AshRandomParams.Random
   def random(%{type: Ash.Type.Integer}, _opts, _context) do
-    777  # Custom random integer
+    777
   end
 
   @impl AshRandomParams.Random
@@ -55,28 +85,24 @@ defmodule MyRandom do
 end
 ```
 
-### Using Random Params
-
-```elixir
-# Basic usage
-Post.random_params!(:create)
-
-# With initial params
-Post.random_params!(:create, %{key: "value"})
-
-# With options
-Post.random_params!(:create, %{key: "value"}, %{
-  fill: [:optional_field],    # Fill optional fields
-  unfill: [:required_field]   # Leave required fields as nil
-})
-```
-
 ## Features
 
 - Automatically generates random values for action accepts and arguments
 - Supports custom random value generators
 - Useful for testing and development
 
+## Installation
+
+Add `ash_random_params` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:ash_random_params, "~> 0.1.0"}
+  ]
+end
+```
+
 ## License
 
 MIT

lib/random/default_random.ex

@@ -15,42 +15,6 @@ defmodule AshRandomParams.DefaultRandom do
     end)
   end
 
-  # Union
-  def random(
-        %{type: _union_type, constraints: [{:types, type_infos} | _]},
-        _opts,
-        %{action_context: action_context} = context
-      ) do
-    ash_opts = action_context |> Ash.Context.to_opts()
-
-    {_subtype_tag, type_info} =
-      case context do
-        %{subtype_tag: subtype_tag} ->
-          type_infos
-          |> Enum.find(fn
-            {^subtype_tag, _type_info} -> true
-            {_, _} -> false
-          end)
-
-        %{} ->
-          type_infos |> Enum.random()
-      end
-
-    subtype = type_info |> Keyword.fetch!(:type)
-    tag = type_info |> Keyword.fetch!(:tag)
-    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)
-    |> Map.from_struct()
-    |> Map.take(attr_names)
-    |> Map.put(tag, tag_value)
-  end
-
   # One of atoms
   def random(%{type: Ash.Type.Atom, constraints: constraints}, _opts, _context) do
     constraints |> Keyword.fetch!(:one_of) |> Enum.random()

lib/transformer.ex

@@ -4,12 +4,6 @@ defmodule AshRandomParams.Transformer do
   alias Ash.Resource.Relationships.BelongsTo
   alias Ash.Resource.Builder
 
-  def before?(Ash.Resource.Transformers.BelongsToAttribute), do: false
-  def before?(_), do: true
-
-  def after?(Ash.Resource.Transformers.BelongsToAttribute), do: true
-  def after?(_), do: false
-
   def transform(dsl_state) do
     dsl_state
     |> add_random_params()
@@ -19,14 +13,14 @@ defmodule AshRandomParams.Transformer do
   def add_random_params(dsl_state) do
     action = Builder.build_action_argument(:action, :atom, default: :create)
     init_params = Builder.build_action_argument(:init_params, :map, default: %{})
-    fill = Builder.build_action_argument(:fill, {:array, :atom}, default: [])
-    unfill = Builder.build_action_argument(:unfill, {:array, :atom}, default: [])
-    tagged_unions = Builder.build_action_argument(:tagged_unions, :map, default: %{})
+    populate = Builder.build_action_argument(:populate, {:array, :atom}, default: [])
+    omit = Builder.build_action_argument(:omit, {:array, :atom}, default: [])
+    include_defaults? = Builder.build_action_argument(:include_defaults?, :boolean, default: true)
 
     dsl_state
     |> Builder.add_action(:action, :random_params,
       returns: :map,
-      arguments: [action, init_params, unfill, fill, tagged_unions],
+      arguments: [action, init_params, omit, populate, include_defaults?],
       run: &__MODULE__.do_random_params/2
     )
     |> Builder.add_interface(:random_params, args: [:action, {:optional, :init_params}])
@@ -50,20 +44,16 @@ defmodule AshRandomParams.Transformer do
           arguments: %{
             action: action,
             init_params: init_params,
-            unfill: unfill,
-            fill: fill,
-            tagged_unions: tagged_unions
+            omit: omit,
+            populate: populate,
+            include_defaults?: include_defaults?
           }
         } =
           input,
         ctx
       ) do
-    {random_mod, random_opts} =
-      random = AshRandomParams.Info.random_params_random!(input.resource)
-
     action = Ash.Resource.Info.action(resource, action)
     init_keys = init_params |> Map.keys()
-    union_keys = tagged_unions |> Map.values()
 
     belongs_to_attrs =
       resource
@@ -84,32 +74,51 @@ defmodule AshRandomParams.Transformer do
 
     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})
+    defaults =
+      if include_defaults? do
+        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)
+        |> Enum.reject(&(&1.name in omit))
+        |> Enum.reject(&(&1.name in init_keys))
+        |> Map.new(fn %{name: name, default: default} ->
+          value =
+            case default do
+              default when is_function(default, 0) ->
+                default.()
+
+              default ->
+                default
+            end
+
+          {name, value}
+        end)
+      else
+        %{}
+      end
 
     generated_params =
       (
-        fields_by_unfill =
+        {random_mod, random_opts} =
+          random = AshRandomParams.Info.random_params_random!(input.resource)
+
+        fields_by_omit =
           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 unfill))
-          |> Enum.reject(& &1.allow_nil?)
+          |> Enum.reject(&(&1.name in omit))
+          |> Enum.reject(&(&1.allow_nil? || &1.default != nil))
 
-        fields_by_fill = candidates |> Enum.filter(&(&1.name in fill))
+        fields_by_fill = candidates |> Enum.filter(&(&1.name in populate))
 
-        (fields_by_unfill ++ fields_by_fill)
+        (fields_by_omit ++ fields_by_fill)
         |> Enum.reject(&(&1.name in init_keys))
         |> Map.new(fn %{name: name, default: default} = attr_or_arg ->
           value =
@@ -128,28 +137,7 @@ defmodule AshRandomParams.Transformer do
         end)
       )
 
-    result_params = placeholder |> Map.merge(init_params) |> Map.merge(generated_params)
-
-    union_params =
-      tagged_unions
-      |> Enum.reject(fn {_tag_field, union_field} -> union_field in init_keys end)
-      |> Map.new(fn {tag_field, union_field} ->
-        union_attr = resource |> Ash.Resource.Info.attribute(union_field)
-        subtype_tag = result_params |> Map.fetch!(tag_field)
-
-        {random_mod, random_opts} = random = AshRandomParams.Info.random_params_random!(resource)
-
-        union_value =
-          random_mod.random(union_attr, random_opts, %{
-            random: random,
-            action_context: ctx,
-            subtype_tag: subtype_tag
-          })
-
-        {union_field, union_value}
-      end)
-
-    result_params = Map.merge(result_params, union_params)
+    result_params = defaults |> Map.merge(init_params) |> Map.merge(generated_params)
 
     {:ok, result_params}
   end

mix.exs

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