Create elixir map to proto converter

Author: VeljkoMaksimovic

ee/ephemeral_environments/lib/ephemeral_environments/grpc/ephemeral_environments_server.ex

@@ -25,8 +25,9 @@ defmodule EphemeralEnvironments.Grpc.EphemeralEnvironmentsServer do
   end
 
   def create(request, _stream) do
-    ret = EphemeralEnvironments.Service.EphemeralEnvironmentType.create(request.environment_type)
-    %CreateResponse{}
+    {:ok, ret} = EphemeralEnvironments.Service.EphemeralEnvironmentType.create(request.environment_type)
+    converted = EphemeralEnvironments.Utils.Proto.from_map(%{environment_type: ret}, CreateResponse)
+    converted
   end
 
   def update(_request, _stream) do

ee/ephemeral_environments/lib/ephemeral_environments/repo/ephemeral_environment_type.ex

@@ -17,7 +17,6 @@ defmodule EphemeralEnvironments.Repo.EphemeralEnvironmentType do
     timestamps()
   end
 
-  @doc false
   def changeset(ephemeral_environment_type, attrs) do
     ephemeral_environment_type
     |> cast(attrs, [

ee/ephemeral_environments/lib/ephemeral_environments/service/ephemeral_environment_type.ex

@@ -15,7 +15,7 @@ defmodule EphemeralEnvironments.Service.EphemeralEnvironmentType do
       - max_number_of_instances (optional)
 
   ## Returns
-    - {:ok, %Schema{}} on success
+    - {:ok, map} on success
     - {:error, String.t()} on validation failure
   """
   def create(attrs) do
@@ -26,11 +26,21 @@ defmodule EphemeralEnvironments.Service.EphemeralEnvironmentType do
     |> Schema.changeset(attrs)
     |> Repo.insert()
     |> case do
-      {:ok, record} -> {:ok, record}
+      {:ok, record} -> {:ok, struct_to_map(record)}
       {:error, changeset} -> {:error, format_errors(changeset)}
     end
   end
 
+  ###
+  ### Helper functions
+  ###
+
+  defp struct_to_map(struct) do
+    struct
+    |> Map.from_struct()
+    |> Map.drop([:__meta__])
+  end
+
   defp format_errors(changeset) do
     Ecto.Changeset.traverse_errors(changeset, fn {msg, opts} ->
       Enum.reduce(opts, msg, fn {key, value}, acc ->

ee/ephemeral_environments/lib/ephemeral_environments/utils/proto.ex

@@ -1,8 +1,37 @@
 defmodule EphemeralEnvironments.Utils.Proto do
   @moduledoc """
-  Utility functions for converting protobuf structs to plain Elixir maps.
+  Utility functions for converting between protobuf structs and plain Elixir maps.
   """
 
+  @doc """
+  Converts an Elixir map to a protobuf struct of the given module type.
+  - Converts DateTime to Google.Protobuf.Timestamp
+  - Converts normalized enum atoms (:ready) to protobuf enum atoms (:TYPE_STATE_READY)
+  - Recursively processes nested maps to nested proto structs
+
+  ## Examples
+
+      from_map(%{name: "test", state: :ready}, InternalApi.EphemeralEnvironments.EphemeralEnvironmentType)
+  """
+  def from_map(nil, _module), do: nil
+
+  def from_map(map, module) when is_map(map) and is_atom(module) do
+    field_props = module.__message_props__().field_props
+
+    # Convert map to struct fields
+    fields =
+      map
+      |> Enum.map(fn {key, value} ->
+        # Find field info for this key
+        field_info = find_field_info(field_props, key)
+        converted_value = convert_value_from_map(value, field_info)
+        {key, converted_value}
+      end)
+      |> Enum.into(%{})
+
+    struct(module, fields)
+  end
+
   @doc """
   Recursively converts a protobuf struct to a plain Elixir map.
   - Converts Google.Protobuf.Timestamp to DateTime
@@ -116,4 +145,80 @@ defmodule EphemeralEnvironments.Utils.Proto do
     |> Macro.underscore()
     |> String.upcase()
   end
+
+  # Find field info by field name atom
+  defp find_field_info(field_props, field_name) do
+    field_props
+    |> Enum.find(fn {_num, props} -> props.name_atom == field_name end)
+    |> case do
+      {_num, props} -> props
+      nil -> nil
+    end
+  end
+
+  defp convert_value_from_map(nil, _field_info), do: nil
+
+  defp convert_value_from_map(%DateTime{} = dt, _field_info) do
+    %Google.Protobuf.Timestamp{
+      seconds: DateTime.to_unix(dt),
+      nanos: 0
+    }
+  end
+
+  @unix_epoch ~N[1970-01-01 00:00:00]
+  defp convert_value_from_map(%NaiveDateTime{} = ndt, _field_info) do
+    %Google.Protobuf.Timestamp{
+      seconds: NaiveDateTime.diff(ndt, @unix_epoch)
+    }
+  end
+
+  defp convert_value_from_map(value, nil), do: value
+
+  defp convert_value_from_map(values, field_info) when is_list(values) do
+    if field_info.embedded? do
+      Enum.map(values, fn item ->
+        if is_map(item) and not is_struct(item) do
+          from_map(item, field_info.type)
+        else
+          item
+        end
+      end)
+    else
+      values
+    end
+  end
+
+  # Handle nested maps (embedded messages)
+  defp convert_value_from_map(value, field_info) when is_map(value) and not is_struct(value) do
+    if field_info.embedded? do
+      from_map(value, field_info.type)
+    else
+      value
+    end
+  end
+
+  # Handle enum atoms - convert normalized atom back to proto enum
+  defp convert_value_from_map(value, field_info) when is_atom(value) do
+    if field_info.enum? do
+      case field_info.type do
+        {:enum, enum_module} -> denormalize_enum_name(value, enum_module)
+        _ -> value
+      end
+    else
+      value
+    end
+  end
+
+  defp convert_value_from_map(value, _field_info), do: value
+
+  # Denormalize enum: :ready -> :TYPE_STATE_READY
+  defp denormalize_enum_name(normalized_atom, enum_module) do
+    prefix = extract_enum_prefix(enum_module)
+
+    normalized_atom
+    |> Atom.to_string()
+    |> String.upcase()
+    |> then(&"#{prefix}_#{&1}")
+    |> String.to_atom()
+  end
 end