Extracted

Author: jechol

.formatter.exs

@@ -0,0 +1,14 @@
+spark_locals_without_parens = [random: 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: Setup 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_random_params-*.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,112 @@
+# AshRandomParams
+
+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.
+
+## Usage
+
+Add the `random_params` DSL to your Ash resource:
+
+```elixir
+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
+    random MyRandom  # Optional: specify your custom random generator
+  end
+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:
+
+```elixir
+defmodule MyRandom do
+  use AshRandomParams.Random
+
+  @impl AshRandomParams.Random
+  def random(%{type: Ash.Type.Integer}, _opts, _context) do
+    777
+  end
+
+  @impl AshRandomParams.Random
+  def random(attr_or_arg, opts, context) do
+    # Fallback to DefaultRandom for all other types
+    AshRandomParams.DefaultRandom.random(attr_or_arg, opts, context)
+  end
+end
+```
+
+## 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
+
+## Links
+
+- [GitHub Repository](https://github.com/devall-org/ash_random_params)

config/config.exs

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

lib/ash_random_params.ex

@@ -0,0 +1,31 @@
+defmodule AshRandomParams do
+  @random_params %Spark.Dsl.Section{
+    name: :random_params,
+    describe: """
+    random_params configuration
+    """,
+    schema: [
+      random: [
+        type:
+          {:spark_function_behaviour, AshRandomParams.Random, {AshRandomParams.RandomFunction, 4}},
+        required: false,
+        default: {AshRandomParams.DefaultRandom, []},
+        doc: """
+        random attribute, argument generation function
+        """
+      ]
+    ],
+    examples: [
+      """
+      random_params do
+        random MyRandom
+      end
+      """
+    ],
+    entities: []
+  }
+
+  use Spark.Dsl.Extension,
+    sections: [@random_params],
+    transformers: [AshRandomParams.Transformer]
+end

lib/info.ex

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

lib/random/default_random.ex

@@ -0,0 +1,61 @@
+defmodule AshRandomParams.DefaultRandom do
+  use AshRandomParams.Random
+
+  # Array
+  def random(
+        %{type: {:array, type}, constraints: constraints, name: name},
+        _opts,
+        %{random: {random_mod, random_opts}} = context
+      ) do
+    min_length = constraints |> Keyword.get(:min_length, 0)
+
+    1..min_length//1
+    |> Enum.map(fn _ ->
+      random_mod.random(%{type: type, name: name}, random_opts, context)
+    end)
+  end
+
+  # One of atoms
+  def random(%{type: Ash.Type.Atom, constraints: constraints}, _opts, _context) do
+    constraints |> Keyword.fetch!(:one_of) |> Enum.random()
+  end
+
+  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: 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}-#{random_int()}"
+
+  def random(%{type: Ash.Type.CiString, name: name}, _opts, _context),
+    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: #{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/random/random.ex

@@ -0,0 +1,13 @@
+defmodule AshRandomParams.Random do
+  @callback random(
+              attr_or_arg :: Ash.Resource.Attribute.t() | Ash.Resource.Actions.Argument.t(),
+              opts :: keyword(),
+              context :: map()
+            ) :: term()
+
+  defmacro __using__(_) do
+    quote do
+      @behaviour AshRandomParams.Random
+    end
+  end
+end