cozy cozy sql

lib/elixir_ai/data/ai_provider.ex

@@ -28,44 +28,44 @@ defmodule ElixirAi.AiProvider do
     sql = "SELECT id, name, model_name FROM ai_providers"
     params = %{}
 
-    case DbHelpers.run_sql(sql, params, "ai_providers") do
-      {:error, :db_error} ->
+    case DbHelpers.run_sql(sql, params, "ai_providers", AiProviderSchema.partial_schema()) do
+      {:error, _} ->
         []
 
-      result ->
-        results =
-          Enum.map(result.rows, fn [id, name, model_name] ->
-            attrs = %{id: id, name: name, model_name: model_name} |> convert_id_to_string()
-
-            case Zoi.parse(AiProviderSchema.partial_schema(), attrs) do
-              {:ok, valid} ->
-                struct(AiProviderSchema, valid)
-
-              {:error, errors} ->
-                Logger.error("Invalid provider data from DB: #{inspect(errors)}")
-                raise ArgumentError, "Invalid provider data: #{inspect(errors)}"
-            end
-          end)
-
-        Logger.debug("AiProvider.all() returning: #{inspect(results)}")
-
-        results
+      rows ->
+        rows
+        |> Enum.map(fn row ->
+          row |> convert_uuid_to_string() |> then(&struct(AiProviderSchema, &1))
+        end)
+        |> tap(&Logger.debug("AiProvider.all() returning: #{inspect(&1)}"))
     end
   end
 
-  # Convert binary UUID to string for frontend
-  defp convert_id_to_string(%{id: id} = provider) when is_binary(id) do
+  defp convert_uuid_to_string(%{id: id} = provider) when is_binary(id) do
     %{provider | id: Ecto.UUID.cast!(id)}
   end
 
-  defp convert_id_to_string(provider), do: provider
+  defp convert_uuid_to_string(provider), do: provider
 
   def create(attrs) do
     now = DateTime.truncate(DateTime.utc_now(), :second)
 
     sql = """
-    INSERT INTO ai_providers (name, model_name, api_token, completions_url, inserted_at, updated_at)
-    VALUES ($(name), $(model_name), $(api_token), $(completions_url), $(inserted_at), $(updated_at))
+    INSERT INTO ai_providers (
+      name,
+      model_name,
+      api_token,
+      completions_url,
+      inserted_at,
+      updated_at
+    ) VALUES (
+      $(name),
+      $(model_name),
+      $(api_token),
+      $(completions_url),
+      $(inserted_at),
+      $(updated_at)
+    )
     """
 
     params = %{
@@ -102,32 +102,10 @@ defmodule ElixirAi.AiProvider do
 
     params = %{"name" => name}
 
-    case DbHelpers.run_sql(sql, params, "ai_providers") do
-      {:error, :db_error} ->
-        {:error, :db_error}
-
-      %{rows: []} ->
-        {:error, :not_found}
-
-      %{rows: [[id, name, model_name, api_token, completions_url] | _]} ->
-        attrs =
-          %{
-            id: id,
-            name: name,
-            model_name: model_name,
-            api_token: api_token,
-            completions_url: completions_url
-          }
-          |> convert_id_to_string()
-
-        case Zoi.parse(AiProviderSchema.schema(), attrs) do
-          {:ok, valid} ->
-            {:ok, struct(AiProviderSchema, valid)}
-
-          {:error, errors} ->
-            Logger.error("Invalid provider data from DB: #{inspect(errors)}")
-            {:error, :invalid_data}
-        end
+    case DbHelpers.run_sql(sql, params, "ai_providers", AiProviderSchema.schema()) do
+      {:error, _} -> {:error, :db_error}
+      [] -> {:error, :not_found}
+      [row | _] -> {:ok, row |> convert_uuid_to_string() |> then(&struct(AiProviderSchema, &1))}
     end
   end
 
@@ -139,9 +117,9 @@ defmodule ElixirAi.AiProvider do
       {:error, :db_error} ->
         {:error, :db_error}
 
-      result ->
-        case result.rows do
-          [[0]] ->
+      rows ->
+        case rows do
+          [%{"count" => 0}] ->
             attrs = %{
               name: "default",
               model_name: Application.fetch_env!(:elixir_ai, :ai_model),

lib/elixir_ai/data/conversation.ex

@@ -34,40 +34,26 @@ defmodule ElixirAi.Conversation do
 
   def all_names do
     sql = """
-    SELECT c.name, p.name, p.model_name, p.api_token, p.completions_url
+    SELECT c.name,
+      json_build_object(
+        'name', p.name,
+        'model_name', p.model_name,
+        'api_token', p.api_token,
+        'completions_url', p.completions_url
+      ) as provider
     FROM conversations c
     LEFT JOIN ai_providers p ON c.ai_provider_id = p.id
     """
 
     params = %{}
 
-    case DbHelpers.run_sql(sql, params, "conversations") do
-      {:error, :db_error} ->
+    case DbHelpers.run_sql(sql, params, "conversations", ConversationInfo.schema()) do
+      {:error, _} ->
         []
 
-      result ->
-        Enum.map(result.rows, fn [name, provider_name, model_name, api_token, completions_url] ->
-          attrs = %{
-            name: name,
-            provider: %{
-              name: provider_name,
-              model_name: model_name,
-              api_token: api_token,
-              completions_url: completions_url
-            }
-          }
-
-          case Zoi.parse(ConversationInfo.schema(), attrs) do
-            {:ok, valid} ->
-              struct(
-                ConversationInfo,
-                Map.put(valid, :provider, struct(Provider, valid.provider))
-              )
-
-            {:error, errors} ->
-              Logger.error("Invalid conversation data: #{inspect(errors)}")
-              raise ArgumentError, "Invalid conversation data: #{inspect(errors)}"
-          end
+      rows ->
+        Enum.map(rows, fn row ->
+          struct(ConversationInfo, Map.put(row, :provider, struct(Provider, row.provider)))
         end)
     end
   end
@@ -76,8 +62,17 @@ defmodule ElixirAi.Conversation do
     case Ecto.UUID.dump(ai_provider_id) do
       {:ok, binary_id} ->
         sql = """
-        INSERT INTO conversations (name, ai_provider_id, inserted_at, updated_at)
-        VALUES ($(name), $(ai_provider_id), $(inserted_at), $(updated_at))
+        INSERT INTO conversations (
+          name,
+          ai_provider_id,
+          inserted_at,
+          updated_at)
+        VALUES (
+          $(name),
+          $(ai_provider_id),
+          $(inserted_at),
+          $(updated_at)
+        )
         """
 
         timestamp = now()
@@ -110,11 +105,11 @@ defmodule ElixirAi.Conversation do
       {:error, :db_error} ->
         {:error, :db_error}
 
-      %{rows: []} ->
+      [] ->
         {:error, :not_found}
 
-      %{rows: [[id] | _]} ->
-        {:ok, id}
+      [row | _] ->
+        {:ok, row["id"]}
     end
   end
 

lib/elixir_ai/data/db_helpers.ex

@@ -2,11 +2,21 @@ defmodule ElixirAi.Data.DbHelpers do
   require Logger
   @get_named_param ~r/\$\((\w+)\)/
 
+  def run_sql(sql, params, topic, schema) do
+    run_sql(sql, params, topic) |> validate_rows(schema, topic)
+  end
+
   def run_sql(sql, params, topic) do
     {sql, params} = named_params_to_positional_params(sql, params)
 
     try do
-      Ecto.Adapters.SQL.query!(ElixirAi.Repo, sql, params)
+      result = Ecto.Adapters.SQL.query!(ElixirAi.Repo, sql, params)
+
+      # Transform rows to maps with column names as keys
+      Enum.map(result.rows, fn row ->
+        Enum.zip(result.columns, row)
+        |> Enum.into(%{})
+      end)
     rescue
       exception ->
         Logger.error("Database error: #{Exception.message(exception)}")
@@ -21,6 +31,31 @@ defmodule ElixirAi.Data.DbHelpers do
     end
   end
 
+  defp validate_rows({:error, :db_error}, _schema, _topic), do: {:error, :db_error}
+
+  defp validate_rows(rows, schema, topic) do
+    rows
+    |> Enum.reduce_while({:ok, []}, fn row, {:ok, acc} ->
+      case Zoi.parse(schema, row, coerce: true) do
+        {:ok, valid} ->
+          {:cont, {:ok, [valid | acc]}}
+
+        {:error, errors} ->
+          Logger.error("Schema validation error: #{inspect(errors)}")
+          {:halt, {:error, :validation_error}}
+      end
+    end)
+    |> then(fn
+      {:ok, valid_rows} ->
+        Enum.reverse(valid_rows)
+
+      error ->
+        Logger.error("Validation error: #{inspect(error)}")
+        Phoenix.PubSub.broadcast(ElixirAi.PubSub, topic, {:sql_result_validation_error, error})
+        error
+    end)
+  end
+
   def named_params_to_positional_params(query, params) do
     param_occurrences = Regex.scan(@get_named_param, query)
 

lib/elixir_ai/data/message.ex

@@ -31,17 +31,9 @@ defmodule ElixirAi.Message do
       {:error, :db_error} ->
         []
 
-      result ->
-        Enum.map(result.rows, fn row ->
-          raw = %{
-            role: Enum.at(row, 0),
-            content: Enum.at(row, 1),
-            reasoning_content: Enum.at(row, 2),
-            tool_calls: Enum.at(row, 3),
-            tool_call_id: Enum.at(row, 4)
-          }
-
-          decoded = decode_message(raw)
+      rows ->
+        Enum.map(rows, fn row ->
+          decoded = decode_message(row)
 
           case Zoi.parse(MessageSchema.schema(), decoded) do
             {:ok, _valid} ->
@@ -69,9 +61,22 @@ defmodule ElixirAi.Message do
       when is_binary(conversation_id) and byte_size(conversation_id) == 16 do
     sql = """
     INSERT INTO messages (
-      conversation_id, role, content, reasoning_content,
-      tool_calls, tool_call_id, inserted_at
-    ) VALUES ($(conversation_id), $(role), $(content), $(reasoning_content), $(tool_calls), $(tool_call_id), $(inserted_at))
+      conversation_id,
+      role,
+      content,
+      reasoning_content,
+      tool_calls,
+      tool_call_id,
+      inserted_at
+    ) VALUES (
+      $(conversation_id),
+      $(role),
+      $(content),
+      $(reasoning_content),
+      $(tool_calls),
+      $(tool_call_id),
+      $(inserted_at)
+    )
     """
 
     params = %{
@@ -114,6 +119,7 @@ defmodule ElixirAi.Message do
 
   defp decode_message(row) do
     row
+    |> Map.new(fn {k, v} -> {String.to_existing_atom(k), v} end)
     |> Map.update!(:role, &String.to_existing_atom/1)
     |> Map.update(:tool_calls, nil, fn
       nil ->