chore: Ash.Subject delegates to sub-modules

Author: chazwatkins

lib/ash/action_input.ex

@@ -463,7 +463,7 @@ defmodule Ash.ActionInput do
   - `set_argument/3` for setting argument values
   - `for_action/4` for providing initial arguments
   """
-  @spec fetch_argument(t, atom | String.t()) :: {:ok, term()} | :error
+  @spec fetch_argument(t, atom | binary) :: {:ok, term()} | :error
   def fetch_argument(input, argument) when is_atom(argument) or is_binary(argument) do
     with :error <- Map.fetch(input.arguments, argument) do
       Map.fetch(input.arguments, to_string(argument))
@@ -507,7 +507,7 @@ defmodule Ash.ActionInput do
   - `set_private_argument/3` for setting private arguments
   - `for_action/4` for providing initial arguments
   """
-  @spec set_argument(input :: t(), name :: atom, value :: term()) :: t()
+  @spec set_argument(input :: t(), name :: atom | binary, value :: term()) :: t()
   def set_argument(input, argument, value) do
     if input.action do
       argument =
@@ -553,6 +553,22 @@ defmodule Ash.ActionInput do
     end
   end
 
+  @doc """
+  Deletes one or more arguments from the subject.
+
+  ## Parameters
+
+    * `subject` - The subject to delete arguments from
+    * `arguments` - Single argument name or list of argument names to delete
+  """
+  def delete_argument(input, argument_or_arguments) do
+    argument_or_arguments
+    |> List.wrap()
+    |> Enum.reduce(input, fn argument, input ->
+      %{input | arguments: Map.delete(input.arguments, argument)}
+    end)
+  end
+
   @doc """
   Sets a private argument value on the action input.
 

lib/ash/query/query.ex

@@ -2796,9 +2796,12 @@ defmodule Ash.Query do
   - `set_argument/3` for adding arguments to queries
   - `for_read/4` for creating queries with arguments
   """
-  @spec get_argument(t, atom) :: term
-  def get_argument(query, argument) when is_atom(argument) do
-    Map.get(query.arguments, argument) || Map.get(query.arguments, to_string(argument))
+  @spec get_argument(t, atom | binary) :: term
+  def get_argument(query, argument) when is_atom(argument) or is_binary(argument) do
+    case fetch_argument(query, argument) do
+      {:ok, value} -> value
+      :error -> nil
+    end
   end
 
   @doc """
@@ -2831,8 +2834,8 @@ defmodule Ash.Query do
   - `set_argument/3` for adding arguments to queries
   - `for_read/4` for creating queries with arguments
   """
-  @spec fetch_argument(t, atom) :: {:ok, term} | :error
-  def fetch_argument(query, argument) when is_atom(argument) do
+  @spec fetch_argument(t, atom | binary) :: {:ok, term} | :error
+  def fetch_argument(query, argument) when is_atom(argument) or is_binary(argument) do
     case Map.fetch(query.arguments, argument) do
       {:ok, value} ->
         {:ok, value}

lib/ash/subject.ex

@@ -121,16 +121,8 @@ defmodule Ash.Subject do
     Ash.Query.set_context(subject, map)
   end
 
-  def set_context(subject, nil), do: subject
-
-  def set_context(subject, map) do
-    %{
-      subject
-      | context:
-          subject.context
-          |> Ash.Helpers.deep_merge_maps(map)
-          |> then(&Ash.Helpers.deep_merge_maps(&1, map[:shared] || %{}))
-    }
+  def set_context(%Ash.ActionInput{} = subject, map) do
+    Ash.ActionInput.set_context(subject, map)
   end
 
   @doc """
@@ -174,32 +166,24 @@ defmodule Ash.Subject do
   @spec get_argument(subject :: t(), argument :: atom() | binary(), default :: term()) :: term()
   def get_argument(subject, argument, default \\ nil)
 
-  def get_argument(subject, argument, default) when is_atom(argument) do
-    value =
-      if Map.has_key?(subject.arguments, argument) do
-        Map.get(subject.arguments, argument)
-      else
-        Map.get(subject.arguments, to_string(argument))
-      end
-
-    if is_nil(value) do
-      default
-    else
-      value
+  def get_argument(%Ash.Changeset{} = subject, argument, default) do
+    case Ash.Changeset.get_argument(subject, argument) do
+      nil -> default
+      value -> value
     end
   end
 
-  def get_argument(subject, argument, default) when is_binary(argument) do
-    subject.arguments
-    |> Enum.find(fn {key, _} ->
-      to_string(key) == argument
-    end)
-    |> case do
-      {_key, value} ->
-        value
+  def get_argument(%Ash.Query{} = subject, argument, default) do
+    case Ash.Query.get_argument(subject, argument) do
+      nil -> default
+      value -> value
+    end
+  end
 
-      _ ->
-        default
+  def get_argument(%Ash.ActionInput{} = subject, argument, default) do
+    case Ash.ActionInput.get_argument(subject, argument) do
+      nil -> default
+      value -> value
     end
   end
 
@@ -224,31 +208,16 @@ defmodule Ash.Subject do
     * `argument` - The argument name (atom or string)
   """
   @spec fetch_argument(subject :: t(), argument :: atom() | binary()) :: {:ok, term()} | :error
-  def fetch_argument(subject, argument) when is_atom(argument) do
-    case Map.fetch(subject.arguments, argument) do
-      {:ok, value} ->
-        {:ok, value}
-
-      :error ->
-        case Map.fetch(subject.arguments, to_string(argument)) do
-          {:ok, value} -> {:ok, value}
-          :error -> :error
-        end
-    end
+  def fetch_argument(%Ash.Changeset{} = subject, argument) do
+    Ash.Changeset.fetch_argument(subject, argument)
   end
 
-  def fetch_argument(subject, argument) when is_binary(argument) do
-    subject.arguments
-    |> Enum.find(fn {key, _} ->
-      to_string(key) == argument
-    end)
-    |> case do
-      {_key, value} ->
-        {:ok, value}
+  def fetch_argument(%Ash.Query{} = subject, argument) do
+    Ash.Query.fetch_argument(subject, argument)
+  end
 
-      _ ->
-        :error
-    end
+  def fetch_argument(%Ash.ActionInput{} = subject, argument) do
+    Ash.ActionInput.fetch_argument(subject, argument)
   end
 
   @doc """
@@ -310,12 +279,8 @@ defmodule Ash.Subject do
     Ash.Query.delete_argument(subject, argument_or_arguments)
   end
 
-  def delete_argument(subject, argument_or_arguments) do
-    argument_or_arguments
-    |> List.wrap()
-    |> Enum.reduce(subject, fn argument, subject ->
-      %{subject | arguments: Map.delete(subject.arguments, argument)}
-    end)
+  def delete_argument(%Ash.ActionInput{} = subject, argument_or_arguments) do
+    Ash.ActionInput.delete_argument(subject, argument_or_arguments)
   end
 
   @doc """
@@ -390,12 +355,8 @@ defmodule Ash.Subject do
     Ash.Query.before_action(subject, callback, opts)
   end
 
-  def before_action(subject, callback, opts) do
-    if opts[:prepend?] do
-      %{subject | before_action: [callback | subject.before_action]}
-    else
-      %{subject | before_action: subject.before_action ++ [callback]}
-    end
+  def before_action(%Ash.ActionInput{} = subject, callback, opts) do
+    Ash.ActionInput.before_action(subject, callback, opts)
   end
 
   @doc """
@@ -424,12 +385,8 @@ defmodule Ash.Subject do
     Ash.Query.after_action(subject, callback)
   end
 
-  def after_action(subject, callback, opts) do
-    if opts[:prepend?] do
-      %{subject | after_action: [callback | subject.after_action]}
-    else
-      %{subject | after_action: subject.after_action ++ [callback]}
-    end
+  def after_action(%Ash.ActionInput{} = subject, callback, opts) do
+    Ash.ActionInput.after_action(subject, callback, opts)
   end
 
   @doc """
@@ -490,12 +447,8 @@ defmodule Ash.Subject do
     Ash.Query.before_transaction(subject, callback, opts)
   end
 
-  def before_transaction(subject, callback, opts) do
-    if opts[:prepend?] do
-      %{subject | before_transaction: [callback | subject.before_transaction]}
-    else
-      %{subject | before_transaction: subject.before_transaction ++ [callback]}
-    end
+  def before_transaction(%Ash.ActionInput{} = subject, callback, opts) do
+    Ash.ActionInput.before_transaction(subject, callback, opts)
   end
 
   @doc """
@@ -566,12 +519,8 @@ defmodule Ash.Subject do
     Ash.Query.after_transaction(subject, callback, opts)
   end
 
-  def after_transaction(subject, callback, opts) do
-    if opts[:prepend?] do
-      %{subject | after_transaction: [callback | subject.after_transaction]}
-    else
-      %{subject | after_transaction: subject.after_transaction ++ [callback]}
-    end
+  def after_transaction(%Ash.ActionInput{} = subject, callback, opts) do
+    Ash.ActionInput.after_transaction(subject, callback, opts)
   end
 
   @doc """
@@ -652,11 +601,7 @@ defmodule Ash.Subject do
     Ash.Query.around_transaction(subject, callback, opts)
   end
 
-  def around_transaction(subject, callback, opts) do
-    if opts[:prepend?] do
-      %{subject | around_transaction: [callback | subject.around_transaction]}
-    else
-      %{subject | around_transaction: subject.around_transaction ++ [callback]}
-    end
+  def around_transaction(%Ash.ActionInput{} = subject, callback, opts) do
+    Ash.ActionInput.around_transaction(subject, callback, opts)
   end
 end

test/subject_test.exs

@@ -181,15 +181,9 @@ defmodule Ash.SubjectTest do
         subject = new_subject(subject_type)
 
         # Set an argument that works for all types
-        result =
-          case subject_type do
-            Ash.ActionInput -> Ash.Subject.set_argument(subject, :name, "value")
-            _ -> Ash.Subject.set_argument(subject, :custom_arg, "value")
-          end
+        result = %{subject | arguments: %{age: 42}}
 
-        expected_arg = if subject_type == Ash.ActionInput, do: :name, else: :custom_arg
-        assert Ash.Subject.get_argument(result, expected_arg) == "value"
-        assert Ash.Subject.get_argument(result, :non_existent) == nil
+        assert Ash.Subject.get_argument(result, :age) == 42
         assert is_struct(result, subject_type)
       end
     end
@@ -199,15 +193,9 @@ defmodule Ash.SubjectTest do
         subject = new_subject(subject_type)
 
         # Set an argument that works for all types
-        result =
-          case subject_type do
-            Ash.ActionInput -> Ash.Subject.set_argument(subject, :name, "value")
-            _ -> Ash.Subject.set_argument(subject, :test_arg, "value")
-          end
+        result = %{subject | arguments: %{"age" => 42}}
 
-        # Should find argument by string key even though it was set with atom
-        expected_arg_str = if subject_type == Ash.ActionInput, do: "name", else: "test_arg"
-        assert Ash.Subject.get_argument(result, expected_arg_str) == "value"
+        assert Ash.Subject.get_argument(result, "age") == 42
         assert is_struct(result, subject_type)
       end
     end
@@ -218,7 +206,6 @@ defmodule Ash.SubjectTest do
 
         assert Ash.Subject.get_argument(subject, :missing_arg, "default_value") == "default_value"
         assert Ash.Subject.get_argument(subject, "missing_arg", :default_atom) == :default_atom
-        assert Ash.Subject.get_argument(subject, :missing_arg, 42) == 42
         assert is_struct(subject, subject_type)
       end
     end
@@ -228,20 +215,9 @@ defmodule Ash.SubjectTest do
         subject = new_subject(subject_type)
 
         # Set an argument that works for all types
-        result =
-          case subject_type do
-            Ash.ActionInput -> Ash.Subject.set_argument(subject, :name, "actual_value")
-            _ -> Ash.Subject.set_argument(subject, :existing_arg, "actual_value")
-          end
-
-        expected_arg = if subject_type == Ash.ActionInput, do: :name, else: :existing_arg
-        expected_arg_str = if subject_type == Ash.ActionInput, do: "name", else: "existing_arg"
-
-        assert Ash.Subject.get_argument(result, expected_arg, "default_value") == "actual_value"
-
-        assert Ash.Subject.get_argument(result, expected_arg_str, "default_value") ==
-                 "actual_value"
+        result = %{subject | arguments: %{name: "actual_value"}}
 
+        assert Ash.Subject.get_argument(result, :name, "default_value") == "actual_value"
         assert is_struct(result, subject_type)
       end
     end
@@ -253,14 +229,10 @@ defmodule Ash.SubjectTest do
         subject = new_subject(subject_type)
 
         # Set an argument that works for all types
-        result =
-          case subject_type do
-            Ash.ActionInput -> Ash.Subject.set_argument(subject, :name, "value")
-            _ -> Ash.Subject.set_argument(subject, :custom_arg, "value")
-          end
+        result = %{subject | arguments: %{"age" => 42, name: "value"}}
 
-        expected_arg = if subject_type == Ash.ActionInput, do: :name, else: :custom_arg
-        assert {:ok, "value"} = Ash.Subject.fetch_argument(result, expected_arg)
+        assert {:ok, "value"} = Ash.Subject.fetch_argument(result, :name)
+        assert {:ok, 42} = Ash.Subject.fetch_argument(result, "age")
         assert :error = Ash.Subject.fetch_argument(result, :missing)
         assert is_struct(result, subject_type)
       end
@@ -271,14 +243,9 @@ defmodule Ash.SubjectTest do
         subject = new_subject(subject_type)
 
         # Set an argument that works for all types
-        result =
-          case subject_type do
-            Ash.ActionInput -> Ash.Subject.set_argument(subject, :name, "value")
-            _ -> Ash.Subject.set_argument(subject, :test_arg, "value")
-          end
+        result = %{subject | arguments: %{"name" => "value"}}
 
-        expected_arg_str = if subject_type == Ash.ActionInput, do: "name", else: "test_arg"
-        assert {:ok, "value"} = Ash.Subject.fetch_argument(result, expected_arg_str)
+        assert {:ok, "value"} = Ash.Subject.fetch_argument(result, :name)
         assert is_struct(result, subject_type)
       end
     end