improvement: add dedicated calculation argument transformer

Author: zachdaniel

.formatter.exs

@@ -11,6 +11,7 @@ spark_locals_without_parens = [
   base_route: 1,
   base_route: 2,
   base_route: 3,
+  calculation_argument_names: 1,
   default_fields: 1,
   delete: 1,
   delete: 2,

documentation/dsls/DSL-AshJsonApi.Resource.md

@@ -71,6 +71,7 @@ end
 | [`derive_filter?`](#json_api-derive_filter?){: #json_api-derive_filter? } | `boolean` | `true` | Whether or not to derive a filter parameter based on the sortable fields of the resource |
 | [`field_names`](#json_api-field_names){: #json_api-field_names } | `:camelize \| :dasherize \| keyword \| (any -> any)` |  | Renames fields (attributes, relationships, calculations, and aggregates) in the JSON:API output and input. Can be one of the atoms `:camelize` or `:dasherize` for automatic conversion, a keyword list of `[ash_name: :json_api_name]` mappings, or a 1-arity function that receives an atom field name and returns the desired JSON:API name (atom or string). ```elixir field_names :camelize  # first_name → firstName field_names :dasherize # first_name → first-name ``` Or with a keyword list: ```elixir field_names [   first_name: :firstName,   last_name: :lastName ] ``` Or with a function for custom logic: ```elixir field_names fn name ->   camelized = name \|> to_string() \|> Macro.camelize()   {first, rest} = String.split_at(camelized, 1)   String.downcase(first) <> rest end ``` Names are applied consistently across serialization, request parsing, sort/filter parameters, field selection, error source pointers, relationship keys, and schema generation. |
 | [`argument_names`](#json_api-argument_names){: #json_api-argument_names } | `:camelize \| :dasherize \| keyword \| (any, any -> any)` |  | Renames action arguments in the JSON:API request body and schema. Can be one of the atoms `:camelize` or `:dasherize` for automatic conversion, a nested keyword list of `[action_name: [ash_name: :json_api_name]]` mappings, or a 2-arity function that receives `(action_name, argument_name)` atoms and returns the desired JSON:API name (atom or string). ```elixir argument_names :camelize  # publish_at → publishAt argument_names :dasherize # publish_at → publish-at ``` Or with a keyword list: ```elixir argument_names [   create: [my_arg: :myArg],   update: [my_arg: :myArg] ] ``` Or with a function: ```elixir argument_names fn _action, name ->   camelized = name \|> to_string() \|> Macro.camelize()   {first, rest} = String.split_at(camelized, 1)   String.downcase(first) <> rest end ``` |
+| [`calculation_argument_names`](#json_api-calculation_argument_names){: #json_api-calculation_argument_names } | `:camelize \| :dasherize \| keyword \| (any, any -> any)` |  | Renames calculation arguments in the JSON:API request and schema. Works the same way as `argument_names` but applies to calculation arguments instead of action arguments. The 2-arity function receives `(calculation_name, argument_name)`. Can be one of the atoms `:camelize` or `:dasherize` for automatic conversion, a nested keyword list of `[calc_name: [ash_name: :json_api_name]]` mappings, or a 2-arity function that receives `(calculation_name, argument_name)` atoms and returns the desired JSON:API name (atom or string). ```elixir calculation_argument_names :camelize  # publish_at → publishAt calculation_argument_names :dasherize # publish_at → publish-at ``` Or with a keyword list: ```elixir calculation_argument_names [   full_name: [separator: :sep] ] ``` Or with a function: ```elixir calculation_argument_names fn _calc, name ->   camelized = name \|> to_string() \|> Macro.camelize()   {first, rest} = String.split_at(camelized, 1)   String.downcase(first) <> rest end ``` |
 
 
 ### json_api.routes

lib/ash_json_api/json_schema/open_api.ex

@@ -2847,7 +2847,15 @@ if Code.ensure_loaded?(OpenApiSpex) do
           {inputs, acc} =
             Enum.reduce(calculation.arguments, {[], acc}, fn argument, {inputs, acc} ->
               {schema, acc} = resource_write_attribute_type(argument, resource, :create, acc)
-              {[{argument.name, schema} | inputs], acc}
+
+              json_key =
+                AshJsonApi.Resource.Info.calculation_argument_to_json_key(
+                  resource,
+                  calculation.name,
+                  argument.name
+                )
+
+              {[{json_key, schema} | inputs], acc}
             end)
 
           inputs = Enum.reverse(inputs)
@@ -2857,7 +2865,13 @@ if Code.ensure_loaded?(OpenApiSpex) do
               if argument.allow_nil? do
                 []
               else
-                [argument.name]
+                [
+                  AshJsonApi.Resource.Info.calculation_argument_to_json_key(
+                    resource,
+                    calculation.name,
+                    argument.name
+                  )
+                ]
               end
             end)
 

lib/ash_json_api/request.ex

@@ -688,7 +688,15 @@ defmodule AshJsonApi.Request do
       |> Enum.find(&(AshJsonApi.Resource.Info.type(&1) == type))
 
     Enum.reduce(field_inputs, request, fn {calculation_name, arguments}, request ->
-      case Ash.Resource.Info.public_calculation(resource, calculation_name) do
+      resolved_name =
+        if resource do
+          AshJsonApi.Resource.Info.json_key_to_field(resource, calculation_name) ||
+            calculation_name
+        else
+          calculation_name
+        end
+
+      case Ash.Resource.Info.public_calculation(resource, resolved_name) do
         nil ->
           add_error(
             request,
@@ -698,12 +706,12 @@ defmodule AshJsonApi.Request do
 
         calculation ->
           Enum.reduce(arguments, request, fn {arg_name, arg_value}, request ->
-            arg_names = AshJsonApi.Resource.Info.argument_names(resource)
+            calc_arg_names = AshJsonApi.Resource.Info.calculation_argument_names(resource)
 
             calculation_arg =
               Enum.find(calculation.arguments, fn argument ->
                 AshJsonApi.Resource.Info.apply_argument_name_mapping(
-                  arg_names,
+                  calc_arg_names,
                   calculation.name,
                   argument.name
                 ) == arg_name

lib/ash_json_api/resource/info.ex

@@ -104,6 +104,18 @@ defmodule AshJsonApi.Resource.Info do
     end
   end
 
+  @doc """
+  Returns the `calculation_argument_names` config for the resource: a keyword list, a 2-arity function,
+  or one of the atoms `:camelize` / `:dasherize` (resolved to the corresponding function).
+  """
+  def calculation_argument_names(resource) do
+    case Extension.get_opt(resource, [:json_api], :calculation_argument_names, [], true) do
+      :camelize -> fn _calc, name -> camelize(name) end
+      :dasherize -> fn _calc, name -> dasherize(name) end
+      other -> other
+    end
+  end
+
   @doc """
   Converts an Ash atom field name (attribute, calculation, aggregate) to its JSON:API
   string key, applying any `field_names` mapping configured on the resource.
@@ -159,12 +171,21 @@ defmodule AshJsonApi.Resource.Info do
     end
   end
 
+  @doc """
+  Converts an Ash calculation argument atom name to its JSON:API string key, applying any
+  `calculation_argument_names` mapping configured on the resource for the given calculation.
+  """
+  def calculation_argument_to_json_key(resource, calc_name, arg_name) do
+    names = calculation_argument_names(resource)
+    apply_argument_name_mapping(names, calc_name, arg_name)
+  end
+
   @doc """
   Converts a JSON:API string key to an Ash argument atom name for the given calculation,
-  applying the reverse of any `argument_names` mapping. Returns `nil` if not found.
+  applying the reverse of any `calculation_argument_names` mapping. Returns `nil` if not found.
   """
   def json_key_to_calculation_argument(resource, calc_name, json_key) do
-    names = argument_names(resource)
+    names = calculation_argument_names(resource)
 
     case Ash.Resource.Info.public_calculation(resource, calc_name) do
       %{arguments: args} ->

lib/ash_json_api/resource/resource.ex

@@ -631,6 +631,44 @@ defmodule AshJsonApi.Resource do
         end
         ```
         """
+      ],
+      calculation_argument_names: [
+        type: {:or, [{:literal, :camelize}, {:literal, :dasherize}, :keyword_list, {:fun, 2}]},
+        doc: """
+        Renames calculation arguments in the JSON:API request and schema.
+
+        Works the same way as `argument_names` but applies to calculation arguments
+        instead of action arguments. The 2-arity function receives
+        `(calculation_name, argument_name)`.
+
+        Can be one of the atoms `:camelize` or `:dasherize` for automatic conversion,
+        a nested keyword list of `[calc_name: [ash_name: :json_api_name]]` mappings,
+        or a 2-arity function that receives `(calculation_name, argument_name)` atoms and
+        returns the desired JSON:API name (atom or string).
+
+        ```elixir
+        calculation_argument_names :camelize  # publish_at → publishAt
+        calculation_argument_names :dasherize # publish_at → publish-at
+        ```
+
+        Or with a keyword list:
+
+        ```elixir
+        calculation_argument_names [
+          full_name: [separator: :sep]
+        ]
+        ```
+
+        Or with a function:
+
+        ```elixir
+        calculation_argument_names fn _calc, name ->
+          camelized = name |> to_string() |> Macro.camelize()
+          {first, rest} = String.split_at(camelized, 1)
+          String.downcase(first) <> rest
+        end
+        ```
+        """
       ]
     ]
   }

test/acceptance/field_names_test.exs

@@ -271,6 +271,95 @@ defmodule Test.Acceptance.FieldNamesTest do
     end
   end
 
+  # ─── Resource with keyword-list calculation_argument_names ───────────────────
+
+  defmodule CalcPost do
+    use Ash.Resource,
+      domain: Test.Acceptance.FieldNamesTest.Domain,
+      data_layer: Ash.DataLayer.Ets,
+      extensions: [AshJsonApi.Resource]
+
+    ets do
+      private?(true)
+    end
+
+    json_api do
+      type "calc_post"
+
+      calculation_argument_names(full_name: [use_separator: :sep])
+
+      routes do
+        base "/calc_posts"
+        get :read
+        index :read
+        post :create
+      end
+    end
+
+    attributes do
+      uuid_primary_key(:id)
+      attribute(:first_name, :string, allow_nil?: false, public?: true)
+      attribute(:last_name, :string, allow_nil?: false, public?: true)
+    end
+
+    actions do
+      default_accept([:first_name, :last_name])
+      defaults([:read, :create, :destroy])
+    end
+
+    calculations do
+      calculate :full_name, :string, expr(first_name <> ^arg(:use_separator) <> last_name) do
+        argument(:use_separator, :string, allow_nil?: false, default: " ")
+        public?(true)
+      end
+    end
+  end
+
+  # ─── Resource with :camelize calculation_argument_names ─────────────────────
+
+  defmodule CamelCalcPost do
+    use Ash.Resource,
+      domain: Test.Acceptance.FieldNamesTest.Domain,
+      data_layer: Ash.DataLayer.Ets,
+      extensions: [AshJsonApi.Resource]
+
+    ets do
+      private?(true)
+    end
+
+    json_api do
+      type "camel_calc_post"
+
+      field_names :camelize
+      calculation_argument_names :camelize
+
+      routes do
+        base "/camel_calc_posts"
+        get :read
+        index :read
+        post :create
+      end
+    end
+
+    attributes do
+      uuid_primary_key(:id)
+      attribute(:first_name, :string, allow_nil?: false, public?: true)
+      attribute(:last_name, :string, allow_nil?: false, public?: true)
+    end
+
+    actions do
+      default_accept([:first_name, :last_name])
+      defaults([:read, :create, :destroy])
+    end
+
+    calculations do
+      calculate :full_name, :string, expr(first_name <> ^arg(:join_string) <> last_name) do
+        argument(:join_string, :string, allow_nil?: false, default: " ")
+        public?(true)
+      end
+    end
+  end
+
   # ─── Resource without any name remapping (baseline) ──────────────────────────
 
   defmodule Widget do
@@ -326,6 +415,8 @@ defmodule Test.Acceptance.FieldNamesTest do
       resource Tag
       resource CamelPost
       resource DashPost
+      resource CalcPost
+      resource CamelCalcPost
       resource Widget
     end
   end
@@ -1000,4 +1091,93 @@ defmodule Test.Acceptance.FieldNamesTest do
       assert List.first(data)["attributes"]["post-title"] == "AAA"
     end
   end
+
+  # ─── calculation_argument_names: keyword list ──────────────────────────────
+
+  describe "calculation_argument_names (keyword list)" do
+    test "calculation argument sent under renamed key via field_inputs" do
+      post =
+        CalcPost
+        |> Ash.Changeset.for_create(:create, %{first_name: "Ada", last_name: "Lovelace"})
+        |> Ash.create!()
+
+      response =
+        Domain
+        |> get(
+          "/calc_posts/#{post.id}?fields[calc_post]=first_name,last_name,full_name&field_inputs[calc_post][full_name][sep]=-",
+          status: 200
+        )
+
+      attrs = response.resp_body["data"]["attributes"]
+      assert attrs["full_name"] == "Ada-Lovelace"
+    end
+
+    test "info helpers use calculation_argument_names not argument_names" do
+      assert AshJsonApi.Resource.Info.calculation_argument_to_json_key(
+               CalcPost,
+               :full_name,
+               :use_separator
+             ) == "sep"
+
+      # argument_to_json_key should NOT rename calc args (it uses argument_names, not calculation_argument_names)
+      assert AshJsonApi.Resource.Info.argument_to_json_key(
+               CalcPost,
+               :full_name,
+               :use_separator
+             ) == "use_separator"
+    end
+
+    test "json_key_to_calculation_argument reverses the mapping" do
+      assert AshJsonApi.Resource.Info.json_key_to_calculation_argument(
+               CalcPost,
+               :full_name,
+               "sep"
+             ) == :use_separator
+    end
+
+    test "json_key_to_calculation_argument returns nil for unknown key" do
+      assert AshJsonApi.Resource.Info.json_key_to_calculation_argument(
+               CalcPost,
+               :full_name,
+               "nonexistent"
+             ) == nil
+    end
+  end
+
+  # ─── calculation_argument_names: :camelize ─────────────────────────────────
+
+  describe "calculation_argument_names (:camelize)" do
+    test "calculation argument sent under camelCase key via field_inputs" do
+      post =
+        CamelCalcPost
+        |> Ash.Changeset.for_create(:create, %{first_name: "Grace", last_name: "Hopper"})
+        |> Ash.create!()
+
+      response =
+        Domain
+        |> get(
+          "/camel_calc_posts/#{post.id}?fields[camel_calc_post]=firstName,lastName,fullName&field_inputs[camel_calc_post][fullName][joinString]=-",
+          status: 200
+        )
+
+      attrs = response.resp_body["data"]["attributes"]
+      assert attrs["fullName"] == "Grace-Hopper"
+    end
+
+    test "info helpers apply camelize to calculation arguments" do
+      assert AshJsonApi.Resource.Info.calculation_argument_to_json_key(
+               CamelCalcPost,
+               :full_name,
+               :join_string
+             ) == "joinString"
+    end
+
+    test "json_key_to_calculation_argument reverses camelize mapping" do
+      assert AshJsonApi.Resource.Info.json_key_to_calculation_argument(
+               CamelCalcPost,
+               :full_name,
+               "joinString"
+             ) == :join_string
+    end
+  end
 end