improvement: add builtin transformers :camelize and :dasherize

Author: zachdaniel

documentation/dsls/DSL-AshJsonApi.Resource.md

@@ -69,8 +69,8 @@ end
 | [`default_fields`](#json_api-default_fields){: #json_api-default_fields } | `list(atom)` |  | The fields to include in the object if the `fields` query parameter does not specify. Defaults to all public |
 | [`derive_sort?`](#json_api-derive_sort?){: #json_api-derive_sort? } | `boolean` | `true` | Whether or not to derive a sort parameter based on the sortable fields of the resource |
 | [`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 } | `keyword \| (any -> any)` |  | Renames fields (attributes, relationships, calculations, and aggregates) in the JSON:API output and input. Can be 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). The function form is useful for applying a blanket transformation such as camelCase: ```elixir field_names fn name ->   camelized = name \|> to_string() \|> Macro.camelize()   {first, rest} = String.split_at(camelized, 1)   String.downcase(first) <> rest end ``` Or with a keyword list: ```elixir field_names [   first_name: :firstName,   last_name: :lastName ] ``` 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 } | `keyword \| (any, any -> any)` |  | Renames action arguments in the JSON:API request body and schema. Can be 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 [   create: [my_arg: :myArg],   update: [my_arg: :myArg] ] ``` Or with a function: ```elixir argument_names fn _action, name ->   name \|> to_string() \|> Macro.camelize() \|> String.downcase_first() end ``` |
+| [`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 ``` |
 
 
 ### json_api.routes

documentation/topics/field-names.md

@@ -12,6 +12,15 @@ These options affect **every** place a field or argument name appears: serializa
 
 ## Renaming fields
 
+### Built-in transformers
+
+Use `:camelize` or `:dasherize` for common conventions:
+
+```elixir
+field_names :camelize  # first_name → firstName
+field_names :dasherize # first_name → first-name
+```
+
 ### Keyword list
 
 Use a keyword list to rename specific fields:
@@ -116,16 +125,7 @@ You can use `field_names` and `argument_names` together. A common pattern is to
 json_api do
   type "user"
 
-  field_names fn name ->
-    camelized = name |> to_string() |> Macro.camelize()
-    {first, rest} = String.split_at(camelized, 1)
-    String.downcase(first) <> rest
-  end
-
-  argument_names fn _action, name ->
-    camelized = name |> to_string() |> Macro.camelize()
-    {first, rest} = String.split_at(camelized, 1)
-    String.downcase(first) <> rest
-  end
+  field_names :camelize
+  argument_names :camelize
 end
 ```

lib/ash_json_api/json_schema/json_schema.ex

@@ -975,14 +975,6 @@ defmodule AshJsonApi.JsonSchema do
 
   defp required_write_attributes(resource, arguments, action, route \\ nil) do
     AshJsonApi.OpenApi.required_write_attributes(resource, arguments, action, route)
-    |> Enum.map(fn atom_name ->
-      # Try argument first, then attribute
-      if Enum.any?(arguments, &(&1.name == atom_name)) do
-        AshJsonApi.Resource.Info.argument_to_json_key(resource, action.name, atom_name)
-      else
-        AshJsonApi.Resource.Info.field_to_json_key(resource, atom_name)
-      end
-    end)
   end
 
   defp write_attributes(resource, arguments, action, route \\ nil) do

lib/ash_json_api/json_schema/open_api.ex

@@ -401,9 +401,7 @@ if Code.ensure_loaded?(OpenApiSpex) do
       |> Ash.Resource.Info.public_attributes()
       |> Enum.reject(&(&1.allow_nil? || AshJsonApi.Resource.only_primary_key?(resource, &1.name)))
       |> Enum.map(fn attr ->
-        resource
-        |> AshJsonApi.Resource.Info.field_to_json_key(attr.name)
-        |> String.to_existing_atom()
+        AshJsonApi.Resource.Info.field_to_json_key(resource, attr.name)
       end)
     end
 
@@ -476,9 +474,7 @@ if Code.ensure_loaded?(OpenApiSpex) do
           |> with_comment_on_included(attr, fields)
 
         json_key =
-          resource
-          |> AshJsonApi.Resource.Info.field_to_json_key(attr.name)
-          |> String.to_existing_atom()
+          AshJsonApi.Resource.Info.field_to_json_key(resource, attr.name)
 
         {Map.put(attrs, json_key, schema), acc}
       end)
@@ -2409,29 +2405,19 @@ if Code.ensure_loaded?(OpenApiSpex) do
                   &1.generated? ||
                   &1.name in Map.get(action, :allow_nil_input, []))
             )
-            |> Enum.map(
-              &(resource
-                |> AshJsonApi.Resource.Info.field_to_json_key(&1.name)
-                |> String.to_existing_atom())
-            )
+            |> Enum.map(&AshJsonApi.Resource.Info.field_to_json_key(resource, &1.name))
         end
 
       argument_names =
         filtered_arguments
         |> Enum.reject(& &1.allow_nil?)
         |> Enum.map(fn arg ->
-          resource
-          |> AshJsonApi.Resource.Info.argument_to_json_key(action.name, arg.name)
-          |> String.to_existing_atom()
+          AshJsonApi.Resource.Info.argument_to_json_key(resource, action.name, arg.name)
         end)
 
       require_attributes =
         Map.get(action, :require_attributes, [])
-        |> Enum.map(
-          &(resource
-            |> AshJsonApi.Resource.Info.field_to_json_key(&1)
-            |> String.to_existing_atom())
-        )
+        |> Enum.map(&AshJsonApi.Resource.Info.field_to_json_key(resource, &1))
 
       Enum.uniq(attribute_names ++ argument_names ++ require_attributes)
     end
@@ -2457,9 +2443,7 @@ if Code.ensure_loaded?(OpenApiSpex) do
               resource_write_attribute_type(attribute, resource, action.type, acc, format)
 
             json_key =
-              resource
-              |> AshJsonApi.Resource.Info.field_to_json_key(attribute.name)
-              |> String.to_existing_atom()
+              AshJsonApi.Resource.Info.field_to_json_key(resource, attribute.name)
 
             {Map.put(attrs, json_key, schema), acc}
           end)
@@ -2473,9 +2457,7 @@ if Code.ensure_loaded?(OpenApiSpex) do
         {schema, acc} = resource_write_attribute_type(argument, resource, :create, acc, format)
 
         json_key =
-          resource
-          |> AshJsonApi.Resource.Info.argument_to_json_key(action.name, argument.name)
-          |> String.to_existing_atom()
+          AshJsonApi.Resource.Info.argument_to_json_key(resource, action.name, argument.name)
 
         {Map.put(attributes, json_key, schema), acc}
       end)
@@ -2512,9 +2494,7 @@ if Code.ensure_loaded?(OpenApiSpex) do
       |> Enum.filter(&has_relationship_argument?(relationship_arguments, &1.name))
       |> Enum.reject(& &1.allow_nil?)
       |> Enum.map(fn arg ->
-        resource
-        |> AshJsonApi.Resource.Info.argument_to_json_key(action.name, arg.name)
-        |> String.to_existing_atom()
+        AshJsonApi.Resource.Info.argument_to_json_key(resource, action.name, arg.name)
       end)
     end
 
@@ -2536,9 +2516,7 @@ if Code.ensure_loaded?(OpenApiSpex) do
         }
 
         json_key =
-          resource
-          |> AshJsonApi.Resource.Info.argument_to_json_key(action.name, argument.name)
-          |> String.to_existing_atom()
+          AshJsonApi.Resource.Info.argument_to_json_key(resource, action.name, argument.name)
 
         {json_key, schema}
       end)

lib/ash_json_api/resource/info.ex

@@ -70,20 +70,38 @@ defmodule AshJsonApi.Resource.Info do
     Extension.get_opt(resource, [:json_api], :default_fields, nil, true)
   end
 
+  defp camelize(name) do
+    camelized = name |> to_string() |> Macro.camelize()
+    {first, rest} = String.split_at(camelized, 1)
+    String.downcase(first) <> rest
+  end
+
+  defp dasherize(name) do
+    name |> to_string() |> String.replace("_", "-")
+  end
+
   @doc """
-  Returns the raw `field_names` config for the resource: either a keyword list or a
-  1-arity function.
+  Returns the `field_names` config for the resource: a keyword list, a 1-arity function,
+  or one of the atoms `:camelize` / `:dasherize` (resolved to the corresponding function).
   """
   def field_names(resource) do
-    Extension.get_opt(resource, [:json_api], :field_names, [], true)
+    case Extension.get_opt(resource, [:json_api], :field_names, [], true) do
+      :camelize -> &camelize/1
+      :dasherize -> &dasherize/1
+      other -> other
+    end
   end
 
   @doc """
-  Returns the raw `argument_names` config for the resource: either a keyword list or a
-  1-arity function.
+  Returns the `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 argument_names(resource) do
-    Extension.get_opt(resource, [:json_api], :argument_names, [], true)
+    case Extension.get_opt(resource, [:json_api], :argument_names, [], true) do
+      :camelize -> fn _action, name -> camelize(name) end
+      :dasherize -> fn _action, name -> dasherize(name) end
+      other -> other
+    end
   end
 
   @doc """

lib/ash_json_api/resource/resource.ex

@@ -558,22 +558,19 @@ defmodule AshJsonApi.Resource do
         default: true
       ],
       field_names: [
-        type: {:or, [:keyword_list, {:fun, 1}]},
+        type: {:or, [{:literal, :camelize}, {:literal, :dasherize}, :keyword_list, {:fun, 1}]},
         doc: """
         Renames fields (attributes, relationships, calculations, and aggregates) in the
         JSON:API output and input.
 
-        Can be 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).
-
-        The function form is useful for applying a blanket transformation such as camelCase:
+        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 fn name ->
-          camelized = name |> to_string() |> Macro.camelize()
-          {first, rest} = String.split_at(camelized, 1)
-          String.downcase(first) <> rest
-        end
+        field_names :camelize  # first_name → firstName
+        field_names :dasherize # first_name → first-name
         ```
 
         Or with a keyword list:
@@ -585,19 +582,37 @@ defmodule AshJsonApi.Resource do
         ]
         ```
 
+        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: [
-        type: {:or, [:keyword_list, {:fun, 2}]},
+        type: {:or, [{:literal, :camelize}, {:literal, :dasherize}, :keyword_list, {:fun, 2}]},
         doc: """
         Renames action arguments in the JSON:API request body and schema.
 
-        Can be 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).
+        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 [
@@ -610,7 +625,9 @@ defmodule AshJsonApi.Resource do
 
         ```elixir
         argument_names fn _action, name ->
-          name |> to_string() |> Macro.camelize() |> String.downcase_first()
+          camelized = name |> to_string() |> Macro.camelize()
+          {first, rest} = String.split_at(camelized, 1)
+          String.downcase(first) <> rest
         end
         ```
         """