fix: properly apply calculations with arguments in filter form

fixes #241

lib/ash_phoenix/filter_form/filter_form.ex

@@ -226,6 +226,11 @@ defmodule AshPhoenix.FilterForm do
       return a list of ash phoenix formatted errors, e.g `[{field :: atom, message :: String.t(), substituations :: Keyword.t()}]`
       """
     ],
+    warn_on_unhandled_errors?: [
+      type: :boolean,
+      default: true,
+      doc: "Whether or not to emit warning log on unhandled form errors"
+    ],
     remove_empty_groups?: [
       type: :boolean,
       doc: """
@@ -435,14 +440,7 @@ defmodule AshPhoenix.FilterForm do
       {:error, %__MODULE__{} = form} ->
         error =
           form
-          |> errors()
-          |> Enum.map(fn
-            {key, message, vars} ->
-              "#{key}: #{AshPhoenix.replace_vars(message, vars)}"
-
-            other ->
-              other
-          end)
+          |> raw_errors()
           |> Ash.Error.to_error_class()
 
         raise error
@@ -456,7 +454,9 @@ defmodule AshPhoenix.FilterForm do
   def to_filter!(form), do: to_filter_expression!(form)
 
   @doc """
-  Returns a flat list of all errors on all predicates in the filter.
+  Returns a flat list of all errors on all predicates in the filter, made safe for display in a form.
+
+  Only errors that implement the `AshPhoenix.FormData.Error` protocol are displayed.
   """
   def errors(form, opts \\ [])
 
@@ -470,6 +470,20 @@ defmodule AshPhoenix.FilterForm do
   def errors(%Predicate{} = predicate, opts),
     do: AshPhoenix.FilterForm.Predicate.errors(predicate, opts[:transform_errors])
 
+  @doc """
+  Returns a flat list of all errors on all predicates in the filter, without transforming.
+  """
+  def raw_errors(%__MODULE__{components: components}) do
+    Enum.flat_map(
+      components,
+      &raw_errors(&1)
+    )
+  end
+
+  def raw_errors(%Predicate{} = predicate) do
+    predicate.errors
+  end
+
   defp do_to_filter_expression(%__MODULE__{components: []}, _), do: {:ok, %{}}
 
   defp do_to_filter_expression(
@@ -482,8 +496,16 @@ defmodule AshPhoenix.FilterForm do
           {:ok, component_filter} ->
             {filters ++ [component_filter], components ++ [component], errors?}
 
-          {:error, component} ->
-            {filters, components ++ [component], true}
+          {:error, errors} ->
+            {filters,
+             components ++
+               [
+                 %{
+                   component
+                   | valid?: false,
+                     errors: List.wrap(component.errors) ++ List.wrap(errors)
+                 }
+               ], true}
         end
       end)
 
@@ -519,23 +541,42 @@ defmodule AshPhoenix.FilterForm do
          resource
        ) do
     ref =
-      case Ash.Resource.Info.public_calculation(Ash.Resource.Info.related(resource, path), field) do
+      case Ash.Resource.Info.public_calculation(
+             Ash.Resource.Info.related(resource, path),
+             field
+           ) do
         nil ->
           {:ok, Ash.Expr.expr(^Ash.Expr.ref(List.wrap(path), field))}
 
-        calc ->
-          case Ash.Query.validate_calculation_arguments(
-                 calc,
-                 arguments.input || %{}
-               ) do
-            {:ok, input} ->
-              {:ok,
-               %Ash.Query.Call{
-                 name: calc.name,
-                 args: [Map.to_list(input)],
-                 relationship_path: path
-               }}
-
+        %{calculation: {module, calc_opts}} = calc ->
+          with {:ok, input} <-
+                 Ash.Query.validate_calculation_arguments(
+                   calc,
+                   arguments.input || %{}
+                 ),
+               {:ok, calc} <-
+                 Ash.Query.Calculation.new(
+                   calc.name,
+                   module,
+                   calc_opts,
+                   calc.type,
+                   calc.constraints,
+                   arguments: input,
+                   async?: calc.async?,
+                   filterable?: calc.filterable?,
+                   sortable?: calc.sortable?,
+                   sensitive?: calc.sensitive?,
+                   load: calc.load,
+                   calc_name: calc.name,
+                   source_context: %{}
+                 ) do
+            {:ok, %Ash.Query.Ref{
+              attribute: calc,
+              relationship_path: path,
+              resource: Ash.Resource.Info.related(resource, path),
+              input?: true
+            }}
+          else
             {:error, error} ->
               {:error, error}
           end
@@ -610,7 +651,7 @@ defmodule AshPhoenix.FilterForm do
         "id" => params[:id] || params["id"] || Ash.UUID.generate(),
         "operator" => to_string(params[:operator] || params["operator"] || "eq"),
         "negated" => params[:negated] || params["negated"] || false,
-        "arguments" => params["arguments"],
+        "arguments" => params[:arguments] || params["arguments"],
         "field" => field,
         "value" => params[:value] || params["value"],
         "path" => path

lib/ash_phoenix/filter_form/predicate.ex

@@ -29,7 +29,7 @@ defmodule AshPhoenix.FilterForm.Predicate do
       {_key, _value, _vars} ->
         true
 
-      _ ->
+      _unhandled ->
         false
     end)
     |> Enum.flat_map(

lib/ash_phoenix/form_data/error.ex

@@ -48,6 +48,12 @@ defimpl AshPhoenix.FormData.Error, for: Ash.Error.Query.InvalidArgument do
   end
 end
 
+defimpl AshPhoenix.FormData.Error, for: Ash.Error.Query.InvalidCalculationArgument do
+  def to_form_error(error) do
+    {error.field, error.message, error.vars}
+  end
+end
+
 defimpl AshPhoenix.FormData.Error, for: Ash.Error.Changes.InvalidAttribute do
   def to_form_error(error) do
     {error.field, error.message, error.vars}

lib/ash_phoenix/plug/exception.ex

@@ -1,6 +1,7 @@
 errors = [
   {Ash.Error.Invalid.InvalidPrimaryKey, 400},
   {Ash.Error.Query.InvalidArgument, 400},
+  {Ash.Error.Query.InvalidCalculationArgument, 400},
   {Ash.Error.Query.InvalidFilterValue, 400},
   {Ash.Error.Query.NotFound, 404},
   {Ash.Error.Forbidden.Policy, 403},

test/filter_form_test.exs

@@ -229,6 +229,28 @@ defmodule AshPhoenix.FilterFormTest do
              )
     end
 
+    test "predicates can have arguments" do
+      form =
+        FilterForm.new(Post,
+          params: %{
+            field: :text_plus_title,
+            operator: :eq,
+            arguments: %{
+              delimiter: "-"
+            },
+            value: "text-title"
+          }
+        )
+
+      assert %{id: match_id} = Ash.create!(Post, %{text: "text", title: "title"})
+      Ash.create!(Post, %{text: "no", title: "bad"})
+
+      assert [%{id: ^match_id}] =
+        Post
+        |> FilterForm.filter!(form)
+        |> Ash.read!()
+    end
+
     test "predicates can reference paths for to_filter_map" do
       form =
         FilterForm.new(Post,

test/support/resources/post.ex

@@ -20,6 +20,13 @@ defmodule AshPhoenix.Test.Post do
     attribute(:custom_atom_field, AshPhoenix.Test.Action, public?: true)
   end
 
+  calculations do
+    calculate :text_plus_title, :string, expr(text <> ^arg(:delimiter) <> title) do
+      public? true
+      argument :delimiter, :string, allow_nil?: false
+    end
+  end
+
   actions do
     default_accept(:*)
     defaults([:read, :destroy])