fix: add support for generic actions returning typed struct(s)

Author: Torkan

lib/ash_typescript/rpc/codegen.ex

@@ -590,6 +590,16 @@ defmodule AshTypescript.Rpc.Codegen do
           {:error, :no_fields_defined}
         end
 
+      {:array, module} when is_atom(module) ->
+        if AshTypescript.Codegen.is_typed_struct?(module) do
+          constraints = action.constraints || []
+          items_constraints = Keyword.get(constraints, :items, [])
+          fields = Keyword.get(items_constraints, :fields, [])
+          {:ok, :array_of_typed_struct, {module, fields}}
+        else
+          {:error, :not_field_selectable_type}
+        end
+
       map_like when map_like in [Ash.Type.Map, Ash.Type.Keyword, Ash.Type.Keyword] ->
         constraints = action.constraints || []
 
@@ -599,6 +609,15 @@ defmodule AshTypescript.Rpc.Codegen do
           {:ok, :unconstrained_map, nil}
         end
 
+      module when is_atom(module) ->
+        if AshTypescript.Codegen.is_typed_struct?(module) do
+          constraints = action.constraints || []
+          fields = Keyword.get(constraints, :fields, [])
+          {:ok, :typed_struct, {module, fields}}
+        else
+          {:error, :not_field_selectable_type}
+        end
+
       _ ->
         {:error, :not_field_selectable_type}
     end
@@ -1068,8 +1087,8 @@ defmodule AshTypescript.Rpc.Codegen do
               """
             end
 
-          {:ok, type, fields} when type in [:typed_map, :array_of_typed_map] ->
-            typed_map_schema = build_map_type(fields)
+          {:ok, type, value} when type in [:typed_map, :array_of_typed_map] ->
+            typed_map_schema = build_map_type(value)
 
             if type == :array_of_typed_map do
               """
@@ -1089,8 +1108,43 @@ defmodule AshTypescript.Rpc.Codegen do
               """
             end
 
+          {:ok, :typed_struct, {module, fields}} ->
+            field_name_mappings =
+              if function_exported?(module, :typescript_field_names, 0) do
+                module.typescript_field_names()
+              else
+                nil
+              end
+
+            typed_map_schema = build_map_type(fields, nil, field_name_mappings)
+
+            """
+            export type #{rpc_action_name_pascal}Fields = UnifiedFieldSelection<#{typed_map_schema}>[];
+
+            type Infer#{rpc_action_name_pascal}Result<
+              Fields extends #{rpc_action_name_pascal}Fields,
+            > = InferResult<#{typed_map_schema}, Fields>;
+            """
+
+          {:ok, :array_of_typed_struct, {module, fields}} ->
+            field_name_mappings =
+              if function_exported?(module, :typescript_field_names, 0) do
+                module.typescript_field_names()
+              else
+                nil
+              end
+
+            typed_map_schema = build_map_type(fields, nil, field_name_mappings)
+
+            """
+            export type #{rpc_action_name_pascal}Fields = UnifiedFieldSelection<#{typed_map_schema}>[];
+
+            type Infer#{rpc_action_name_pascal}Result<
+              Fields extends #{rpc_action_name_pascal}Fields,
+            > = Array<InferResult<#{typed_map_schema}, Fields>>;
+            """
+
           {:ok, :unconstrained_map, _} ->
-            # Unconstrained maps return Record<string, any> without field selection
             """
             type Infer#{rpc_action_name_pascal}Result = Record<string, any>;
             """
@@ -1820,7 +1874,13 @@ defmodule AshTypescript.Rpc.Codegen do
 
                 {updated_fields, true, "Fields extends #{rpc_action_name_pascal}Fields"}
 
-              {:ok, type, _fields} when type in [:typed_map, :array_of_typed_map] ->
+              {:ok, type, _fields}
+              when type in [
+                     :typed_map,
+                     :array_of_typed_map,
+                     :typed_struct,
+                     :array_of_typed_struct
+                   ] ->
                 updated_fields =
                   config_fields ++
                     [
@@ -2324,7 +2384,13 @@ defmodule AshTypescript.Rpc.Codegen do
 
                 {updated_fields, true, "Fields extends #{rpc_action_name_pascal}Fields"}
 
-              {:ok, type, _fields} when type in [:typed_map, :array_of_typed_map] ->
+              {:ok, type, _fields}
+              when type in [
+                     :typed_map,
+                     :array_of_typed_map,
+                     :typed_struct,
+                     :array_of_typed_struct
+                   ] ->
                 updated_fields =
                   config_fields ++
                     [

lib/ash_typescript/rpc/pipeline.ex

@@ -204,8 +204,15 @@ defmodule AshTypescript.Rpc.Pipeline do
         if unconstrained_map_action?(request.action) do
           {:ok, ResultProcessor.normalize_value_for_json(result)}
         else
+          resource_for_mapping =
+            if request.action.type == :action and returns_typed_struct?(request.action) do
+              nil
+            else
+              request.resource
+            end
+
           filtered =
-            ResultProcessor.process(result, request.extraction_template, request.resource)
+            ResultProcessor.process(result, request.extraction_template, resource_for_mapping)
 
           filtered_with_metadata = add_metadata(filtered, result, request)
 
@@ -217,6 +224,19 @@ defmodule AshTypescript.Rpc.Pipeline do
     end
   end
 
+  defp returns_typed_struct?(action) do
+    case action.returns do
+      {:array, module} when is_atom(module) ->
+        AshTypescript.Codegen.is_typed_struct?(module)
+
+      module when is_atom(module) ->
+        AshTypescript.Codegen.is_typed_struct?(module)
+
+      _ ->
+        false
+    end
+  end
+
   @doc """
   Stage 4: Format output for client consumption.
 

lib/ash_typescript/rpc/requested_fields_processor.ex

@@ -132,10 +132,22 @@ defmodule AshTypescript.Rpc.RequestedFieldsProcessor do
         fake_attribute = %{type: type, constraints: constraints}
 
         if is_typed_struct?(fake_attribute) do
+          if requested_fields == [] do
+            throw({:requires_field_selection, :typed_struct, nil})
+          end
+
           field_specs = Keyword.get(constraints, :fields, [])
+          instance_of = Keyword.get(constraints, :instance_of)
+
+          field_name_mappings =
+            if instance_of && function_exported?(instance_of, :typescript_field_names, 0) do
+              instance_of.typescript_field_names()
+            else
+              []
+            end
 
           {_field_names, template_items} =
-            process_typed_struct_fields(requested_fields, field_specs, path)
+            process_typed_struct_fields(requested_fields, field_specs, path, field_name_mappings)
 
           {[], [], template_items}
         else
@@ -702,20 +714,33 @@ defmodule AshTypescript.Rpc.RequestedFieldsProcessor do
 
     attribute = Ash.Resource.Info.attribute(resource, field_name)
     field_specs = Keyword.get(attribute.constraints, :fields, [])
+    instance_of = Keyword.get(attribute.constraints, :instance_of)
+
+    field_name_mappings =
+      if instance_of && function_exported?(instance_of, :typescript_field_names, 0) do
+        instance_of.typescript_field_names()
+      else
+        []
+      end
 
     new_path = path ++ [field_name]
 
     {_field_names, template_items} =
-      process_typed_struct_fields(nested_fields, field_specs, new_path)
+      process_typed_struct_fields(nested_fields, field_specs, new_path, field_name_mappings)
 
     new_select = select ++ [field_name]
 
     {new_select, load, template ++ [{field_name, template_items}]}
   end
 
-  defp process_typed_struct_fields(requested_fields, field_specs, path) do
+  defp process_typed_struct_fields(requested_fields, field_specs, path, field_name_mappings) do
     check_for_duplicate_fields(requested_fields, path)
 
+    reverse_mappings =
+      Enum.into(field_name_mappings, %{}, fn {elixir_name, ts_name} ->
+        {ts_name, elixir_name}
+      end)
+
     {field_names, template_items} =
       Enum.reduce(requested_fields, {[], []}, fn field, {names, template} ->
         case field do
@@ -727,32 +752,31 @@ defmodule AshTypescript.Rpc.RequestedFieldsProcessor do
                 field_atom
               end
 
-            if Keyword.has_key?(field_specs, field_atom) do
-              {names ++ [field_atom], template ++ [field_atom]}
+            elixir_field_name = Map.get(reverse_mappings, field_atom, field_atom)
+
+            if Keyword.has_key?(field_specs, elixir_field_name) do
+              {names ++ [elixir_field_name], template ++ [elixir_field_name]}
             else
               field_path = build_field_path(path, field_atom)
               throw({:unknown_field, field_atom, "typed_struct", field_path})
             end
 
           %{} = field_map ->
-            # Handle nested field selection for maps with field constraints
             {new_names, new_template} =
               Enum.reduce(field_map, {names, template}, fn {field_name, nested_fields}, {n, t} ->
-                if Keyword.has_key?(field_specs, field_name) do
-                  field_spec = Keyword.get(field_specs, field_name)
+                elixir_field_name = Map.get(reverse_mappings, field_name, field_name)
+
+                if Keyword.has_key?(field_specs, elixir_field_name) do
+                  field_spec = Keyword.get(field_specs, elixir_field_name)
                   field_type = Keyword.get(field_spec, :type)
                   field_constraints = Keyword.get(field_spec, :constraints, [])
-
-                  # Determine the return type for this field
                   field_return_type = {:ash_type, field_type, field_constraints}
-                  new_path = path ++ [field_name]
+                  new_path = path ++ [elixir_field_name]
 
-                  # Process the nested fields based on the field's type
                   {_nested_select, _nested_load, nested_template} =
                     process_fields_for_type(field_return_type, nested_fields, new_path)
 
-                  # For typed struct fields, we only need the template
-                  {n ++ [field_name], t ++ [{field_name, nested_template}]}
+                  {n ++ [elixir_field_name], t ++ [{elixir_field_name, nested_template}]}
                 else
                   field_path = build_field_path(path, field_name)
                   throw({:unknown_field, field_name, "typed_struct", field_path})

lib/ash_typescript/rpc/result_processor.ex

@@ -68,6 +68,14 @@ defmodule AshTypescript.Rpc.ResultProcessor do
        when is_list(extraction_template) do
     is_tuple = is_tuple(data)
 
+    typed_struct_module =
+      if is_map(data) and not is_tuple(data) and Map.has_key?(data, :__struct__) do
+        module = data.__struct__
+        if AshTypescript.Codegen.is_typed_struct?(module), do: module, else: nil
+      else
+        nil
+      end
+
     normalized_data =
       cond do
         is_tuple ->
@@ -80,16 +88,24 @@ defmodule AshTypescript.Rpc.ResultProcessor do
           normalize_data(data)
       end
 
+    effective_resource = resource || typed_struct_module
+
     if is_tuple do
       normalized_data
     else
       Enum.reduce(extraction_template, %{}, fn field_spec, acc ->
         case field_spec do
           field_atom when is_atom(field_atom) or is_tuple(data) ->
-            extract_simple_field(normalized_data, field_atom, acc, resource)
+            extract_simple_field(normalized_data, field_atom, acc, effective_resource)
 
           {field_atom, nested_template} when is_atom(field_atom) and is_list(nested_template) ->
-            extract_nested_field(normalized_data, field_atom, nested_template, acc, resource)
+            extract_nested_field(
+              normalized_data,
+              field_atom,
+              nested_template,
+              acc,
+              effective_resource
+            )
 
           _ ->
             acc
@@ -103,12 +119,10 @@ defmodule AshTypescript.Rpc.ResultProcessor do
     normalize_data(data)
   end
 
-  # Extract a simple field, handling forbidden, not loaded, and nil cases
   defp extract_simple_field(normalized_data, field_atom, acc, resource) do
-    # Map the Elixir field name to the TypeScript field name for output
     output_field_name =
       if resource do
-        AshTypescript.Resource.Info.get_mapped_field_name(resource, field_atom)
+        get_mapped_field_name(resource, field_atom)
       else
         field_atom
       end
@@ -128,12 +142,10 @@ defmodule AshTypescript.Rpc.ResultProcessor do
     end
   end
 
-  # Extract a nested field with template, handling forbidden, not loaded, and nil cases
   defp extract_nested_field(normalized_data, field_atom, nested_template, acc, resource) do
-    # Map the Elixir field name to the TypeScript field name for output
     output_field_name =
       if resource do
-        AshTypescript.Resource.Info.get_mapped_field_name(resource, field_atom)
+        get_mapped_field_name(resource, field_atom)
       else
         field_atom
       end
@@ -428,4 +440,20 @@ defmodule AshTypescript.Rpc.ResultProcessor do
       nil
     end
   end
+
+  defp get_mapped_field_name(module, field_atom) when is_atom(module) do
+    cond do
+      Ash.Resource.Info.resource?(module) ->
+        AshTypescript.Resource.Info.get_mapped_field_name(module, field_atom)
+
+      Code.ensure_loaded?(module) and function_exported?(module, :typescript_field_names, 0) ->
+        mappings = module.typescript_field_names()
+        Keyword.get(mappings, field_atom, field_atom)
+
+      true ->
+        field_atom
+    end
+  end
+
+  defp get_mapped_field_name(_module, field_atom), do: field_atom
 end