database updates

lib/elixir_ai/data/ai_provider.ex

@@ -1,30 +1,55 @@
 defmodule ElixirAi.AiProvider do
-  use ElixirAi.Data
-  alias ElixirAi.Repo
-  alias ElixirAi.Data.AiProviderSchema
+  alias ElixirAi.Data.DbHelpers
+  require Logger
+
+  defmodule AiProviderSchema do
+    defstruct [:id, :name, :model_name, :api_token, :completions_url]
+
+    def schema do
+      Zoi.object(%{
+        id: Zoi.optional(Zoi.string()),
+        name: Zoi.string(),
+        model_name: Zoi.string(),
+        api_token: Zoi.string(),
+        completions_url: Zoi.string()
+      })
+    end
+
+    def partial_schema do
+      Zoi.object(%{
+        id: Zoi.optional(Zoi.string()),
+        name: Zoi.string(),
+        model_name: Zoi.string()
+      })
+    end
+  end
 
   def all do
-    broadcast_error topic: "ai_providers" do
-      sql = "SELECT id, name, model_name FROM ai_providers"
-      result = Ecto.Adapters.SQL.query!(Repo, sql, [])
+    sql = "SELECT id, name, model_name FROM ai_providers"
+    params = %{}
 
-      results =
-        Enum.map(result.rows, fn [id, name, model_name] ->
-          attrs = %{id: id, name: name, model_name: model_name} |> convert_id_to_string()
+    case DbHelpers.run_sql(sql, params, "ai_providers") do
+      {:error, :db_error} ->
+        []
 
-          case Zoi.parse(AiProviderSchema.partial_schema(), attrs) do
-            {:ok, valid} ->
-              struct(AiProviderSchema, valid)
+      result ->
+        results =
+          Enum.map(result.rows, fn [id, name, model_name] ->
+            attrs = %{id: id, name: name, model_name: model_name} |> convert_id_to_string()
 
-            {:error, errors} ->
-              Logger.error("Invalid provider data from DB: #{inspect(errors)}")
-              raise ArgumentError, "Invalid provider data: #{inspect(errors)}"
-          end
-        end)
+            case Zoi.parse(AiProviderSchema.partial_schema(), attrs) do
+              {:ok, valid} ->
+                struct(AiProviderSchema, valid)
 
-      Logger.debug("AiProvider.all() returning: #{inspect(results)}")
+              {:error, errors} ->
+                Logger.error("Invalid provider data from DB: #{inspect(errors)}")
+                raise ArgumentError, "Invalid provider data: #{inspect(errors)}"
+            end
+          end)
 
-      results
+        Logger.debug("AiProvider.all() returning: #{inspect(results)}")
+
+        results
     end
   end
 
@@ -36,83 +61,99 @@ defmodule ElixirAi.AiProvider do
   defp convert_id_to_string(provider), do: provider
 
   def create(attrs) do
-    broadcast_error topic: "ai_providers" do
-      now = DateTime.truncate(DateTime.utc_now(), :second)
+    now = DateTime.truncate(DateTime.utc_now(), :second)
 
-      sql = """
-      INSERT INTO ai_providers (name, model_name, api_token, completions_url, inserted_at, updated_at)
-      VALUES ($1, $2, $3, $4, $5, $6)
-      """
+    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))
+    """
 
-      params = [attrs.name, attrs.model_name, attrs.api_token, attrs.completions_url, now, now]
+    params = %{
+      "name" => attrs.name,
+      "model_name" => attrs.model_name,
+      "api_token" => attrs.api_token,
+      "completions_url" => attrs.completions_url,
+      "inserted_at" => now,
+      "updated_at" => now
+    }
 
-      Ecto.Adapters.SQL.query!(Repo, sql, params)
+    case DbHelpers.run_sql(sql, params, "ai_providers") do
+      {:error, :db_error} ->
+        {:error, :db_error}
 
-      Phoenix.PubSub.broadcast(
-        ElixirAi.PubSub,
-        "ai_providers",
-        {:provider_added, attrs}
-      )
+      _result ->
+        Phoenix.PubSub.broadcast(
+          ElixirAi.PubSub,
+          "ai_providers",
+          {:provider_added, attrs}
+        )
 
-      :ok
+        :ok
     end
   end
 
   def find_by_name(name) do
-    broadcast_error topic: "ai_providers" do
-      sql = """
-      SELECT id, name, model_name, api_token, completions_url
-      FROM ai_providers
-      WHERE name = $1
-      LIMIT 1
-      """
+    sql = """
+    SELECT id, name, model_name, api_token, completions_url
+    FROM ai_providers
+    WHERE name = $(name)
+    LIMIT 1
+    """
 
-      case Ecto.Adapters.SQL.query!(Repo, sql, [name]) do
-        %{rows: []} ->
-          {:error, :not_found}
+    params = %{"name" => name}
 
-        %{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 DbHelpers.run_sql(sql, params, "ai_providers") do
+      {:error, :db_error} ->
+        {:error, :db_error}
 
-          case Zoi.parse(AiProviderSchema.schema(), attrs) do
-            {:ok, valid} ->
-              {:ok, struct(AiProviderSchema, valid)}
+      %{rows: []} ->
+        {:error, :not_found}
 
-            {:error, errors} ->
-              Logger.error("Invalid provider data from DB: #{inspect(errors)}")
-              {:error, :invalid_data}
-          end
-      end
+      %{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
     end
   end
 
   def ensure_default_provider do
-    broadcast_error topic: "ai_providers" do
-      sql = "SELECT COUNT(*) FROM ai_providers"
-      result = Ecto.Adapters.SQL.query!(Repo, sql, [])
+    sql = "SELECT COUNT(*) FROM ai_providers"
+    params = %{}
 
-      case result.rows do
-        [[0]] ->
-          attrs = %{
-            name: "default",
-            model_name: Application.fetch_env!(:elixir_ai, :ai_model),
-            api_token: Application.fetch_env!(:elixir_ai, :ai_token),
-            completions_url: Application.fetch_env!(:elixir_ai, :ai_endpoint)
-          }
+    case DbHelpers.run_sql(sql, params, "ai_providers") do
+      {:error, :db_error} ->
+        {:error, :db_error}
 
-          create(attrs)
+      result ->
+        case result.rows do
+          [[0]] ->
+            attrs = %{
+              name: "default",
+              model_name: Application.fetch_env!(:elixir_ai, :ai_model),
+              api_token: Application.fetch_env!(:elixir_ai, :ai_token),
+              completions_url: Application.fetch_env!(:elixir_ai, :ai_endpoint)
+            }
 
-        _ ->
-          :ok
-      end
+            create(attrs)
+
+          _ ->
+            :ok
+        end
     end
   end
 end