fix: Add some more RETURNING clause tests, and fix JSON encoding and …

lib/ecto/adapters/libsql.ex

@@ -215,6 +215,9 @@ defmodule Ecto.Adapters.LibSql do
   def loaders(:date, type), do: [&date_decode/1, type]
   def loaders(:time, type), do: [&time_decode/1, type]
   def loaders(:decimal, type), do: [&decimal_decode/1, type]
+  def loaders(:json, type), do: [&json_decode/1, type]
+  def loaders(:map, type), do: [&json_decode/1, type]
+  def loaders({:array, _}, type), do: [&json_array_decode/1, type]
   def loaders(_primitive, type), do: [type]
 
   defp bool_decode(0), do: {:ok, false}
@@ -265,6 +268,31 @@ defmodule Ecto.Adapters.LibSql do
 
   defp decimal_decode(value), do: {:ok, value}
 
+  defp json_decode(value) when is_binary(value) do
+    case Jason.decode(value) do
+      {:ok, decoded} -> {:ok, decoded}
+      {:error, _} -> :error
+    end
+  end
+
+  defp json_decode(value) when is_map(value), do: {:ok, value}
+  defp json_decode(value), do: {:ok, value}
+
+  defp json_array_decode(value) when is_binary(value) do
+    case value do
+      "" -> {:ok, []}  # Empty string defaults to empty array
+      _ ->
+        case Jason.decode(value) do
+          {:ok, decoded} when is_list(decoded) -> {:ok, decoded}
+          {:ok, _} -> :error
+          {:error, _} -> :error
+        end
+    end
+  end
+
+  defp json_array_decode(value) when is_list(value), do: {:ok, value}
+  defp json_array_decode(_value), do: :error
+
   @doc false
   def dumpers(:binary, type), do: [type]
   def dumpers(:binary_id, type), do: [type]
@@ -274,11 +302,18 @@ defmodule Ecto.Adapters.LibSql do
   def dumpers(:date, type), do: [type, &date_encode/1]
   def dumpers(:time, type), do: [type, &time_encode/1]
   def dumpers(:decimal, type), do: [type, &decimal_encode/1]
+  def dumpers(:json, type), do: [type, &json_encode/1]
+  def dumpers(:map, type), do: [type, &json_encode/1]
+  def dumpers({:array, _}, type), do: [type, &array_encode/1]
   def dumpers(_primitive, type), do: [type]
 
   defp bool_encode(false), do: {:ok, 0}
   defp bool_encode(true), do: {:ok, 1}
 
+  defp datetime_encode(%DateTime{} = datetime) do
+    {:ok, DateTime.to_iso8601(datetime)}
+  end
+
   defp datetime_encode(%NaiveDateTime{} = datetime) do
     {:ok, NaiveDateTime.to_iso8601(datetime)}
   end
@@ -294,4 +329,21 @@ defmodule Ecto.Adapters.LibSql do
   defp decimal_encode(%Decimal{} = decimal) do
     {:ok, Decimal.to_string(decimal)}
   end
+
+  defp json_encode(value) when is_binary(value), do: {:ok, value}
+  defp json_encode(value) when is_map(value) or is_list(value) do
+    case Jason.encode(value) do
+      {:ok, json} -> {:ok, json}
+      {:error, _} -> :error
+    end
+  end
+  defp json_encode(value), do: {:ok, value}
+
+  defp array_encode(value) when is_list(value) do
+    case Jason.encode(value) do
+      {:ok, json} -> {:ok, json}
+      {:error, _} -> :error
+    end
+  end
+  defp array_encode(value), do: {:ok, value}
 end

test/ecto_returning_test.exs

@@ -0,0 +1,104 @@
+defmodule EctoLibSql.EctoReturningStructTest do
+  use ExUnit.Case, async: false
+
+  defmodule TestRepo do
+    use Ecto.Repo, otp_app: :ecto_libsql, adapter: Ecto.Adapters.LibSql
+  end
+
+  defmodule User do
+    use Ecto.Schema
+    import Ecto.Changeset
+
+    schema "users" do
+      field :name, :string
+      field :email, :string
+      timestamps()
+    end
+
+    def changeset(user, attrs) do
+      user
+      |> cast(attrs, [:name, :email])
+      |> validate_required([:name, :email])
+    end
+  end
+
+  @test_db "z_ecto_libsql_test-ecto_returning.db"
+
+  setup_all do
+    {:ok, _} = TestRepo.start_link(database: @test_db)
+
+    # Create table
+    Ecto.Adapters.SQL.query!(TestRepo, """
+    CREATE TABLE IF NOT EXISTS users (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      email TEXT NOT NULL,
+      inserted_at DATETIME,
+      updated_at DATETIME
+    )
+    """)
+
+    on_exit(fn ->
+      EctoLibSql.TestHelpers.cleanup_db_files(@test_db)
+    end)
+
+    :ok
+  end
+
+  test "Repo.insert returns populated struct with id and timestamps" do
+    changeset = User.changeset(%User{}, %{name: "Alice", email: "alice@example.com"})
+
+    IO.puts("\n=== Test: INSERT RETURNING via Repo.insert ===")
+    result = TestRepo.insert(changeset)
+
+    IO.inspect(result, label: "Insert result")
+
+    case result do
+      {:ok, user} ->
+        IO.inspect(user, label: "Returned user struct")
+
+        # These assertions should pass if RETURNING struct mapping works
+        assert user.id != nil, "❌ FAIL: ID is nil (struct mapping broken)"
+        assert is_integer(user.id) and user.id > 0, "ID should be positive integer"
+        assert user.name == "Alice", "Name should match"
+        assert user.email == "alice@example.com", "Email should match"
+        assert user.inserted_at != nil, "❌ FAIL: inserted_at is nil (timestamp conversion broken)"
+        assert user.updated_at != nil, "❌ FAIL: updated_at is nil (timestamp conversion broken)"
+
+        IO.puts("✅ PASS: Struct mapping and timestamp conversion working")
+        :ok
+
+      {:error, changeset} ->
+        IO.inspect(changeset, label: "Error changeset")
+        flunk("Insert failed: #{inspect(changeset)}")
+    end
+  end
+
+  test "Multiple inserts return correctly populated structs" do
+    results =
+      for i <- 1..3 do
+        user_data = %{
+          name: "User#{i}",
+          email: "user#{i}@example.com"
+        }
+
+        changeset = User.changeset(%User{}, user_data)
+        {:ok, user} = TestRepo.insert(changeset)
+        user
+      end
+
+    assert length(results) == 3
+
+    Enum.each(results, fn user ->
+      assert user.id != nil, "All users should have IDs"
+      assert user.inserted_at != nil, "All users should have inserted_at"
+      assert user.updated_at != nil, "All users should have updated_at"
+    end)
+
+    # IDs should be unique
+    ids = Enum.map(results, & &1.id)
+    assert length(Enum.uniq(ids)) == 3, "All IDs should be unique"
+
+    IO.puts("✅ PASS: Multiple inserts return populated structs")
+  end
+end

test/returning_test.exs

@@ -0,0 +1,77 @@
+defmodule EctoLibSql.ReturningTest do
+  use ExUnit.Case, async: true
+
+  setup do
+    {:ok, conn} = DBConnection.start_link(EctoLibSql, database: ":memory:")
+    {:ok, conn: conn}
+  end
+
+  test "INSERT RETURNING returns columns and rows", %{conn: conn} do
+    # Create table
+    {:ok, _, _} =
+      DBConnection.execute(
+        conn,
+        %EctoLibSql.Query{statement: "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"},
+        []
+      )
+
+    # Insert with RETURNING
+    query = %EctoLibSql.Query{statement: "INSERT INTO users (name, email) VALUES (?, ?) RETURNING id, name, email"}
+    {:ok, _, result} = DBConnection.execute(conn, query, ["Alice", "alice@example.com"])
+
+    IO.inspect(result, label: "INSERT RETURNING result")
+
+    # Check structure
+    assert result.columns != nil, "Columns should not be nil"
+    assert result.rows != nil, "Rows should not be nil"
+    assert length(result.columns) == 3, "Should have 3 columns"
+    assert length(result.rows) == 1, "Should have 1 row"
+
+    # Check values
+    [[id, name, email]] = result.rows
+    IO.puts("ID: #{inspect(id)}, Name: #{inspect(name)}, Email: #{inspect(email)}")
+
+    assert is_integer(id), "ID should be integer"
+    assert id > 0, "ID should be positive"
+    assert name == "Alice", "Name should match"
+    assert email == "alice@example.com", "Email should match"
+  end
+
+  test "INSERT RETURNING with timestamps", %{conn: conn} do
+    # Create table with timestamps
+    {:ok, _, _} =
+      DBConnection.execute(
+        conn,
+        %EctoLibSql.Query{
+          statement:
+            "CREATE TABLE posts (id INTEGER PRIMARY KEY, title TEXT, inserted_at TEXT, updated_at TEXT)"
+        },
+        []
+      )
+
+    # Insert with RETURNING
+    now = DateTime.utc_now() |> DateTime.to_iso8601()
+
+    query = %EctoLibSql.Query{
+      statement:
+        "INSERT INTO posts (title, inserted_at, updated_at) VALUES (?, ?, ?) RETURNING id, title, inserted_at, updated_at"
+    }
+
+    {:ok, _, result} = DBConnection.execute(conn, query, ["Test Post", now, now])
+
+    IO.inspect(result, label: "INSERT RETURNING with timestamps")
+
+    assert result.columns == ["id", "title", "inserted_at", "updated_at"]
+    [[id, title, inserted_at, updated_at]] = result.rows
+
+    IO.puts("ID: #{inspect(id)}")
+    IO.puts("Title: #{inspect(title)}")
+    IO.puts("inserted_at: #{inspect(inserted_at)}")
+    IO.puts("updated_at: #{inspect(updated_at)}")
+
+    assert is_integer(id)
+    assert title == "Test Post"
+    assert is_binary(inserted_at) or inserted_at == now
+    assert is_binary(updated_at) or updated_at == now
+  end
+end

test/type_compatibility_test.exs

@@ -0,0 +1,121 @@
+defmodule EctoLibSql.TypeCompatibilityTest do
+  use ExUnit.Case, async: false
+
+  defmodule TestRepo do
+    use Ecto.Repo, otp_app: :ecto_libsql, adapter: Ecto.Adapters.LibSql
+  end
+
+  defmodule Record do
+    use Ecto.Schema
+    import Ecto.Changeset
+
+    schema "records" do
+      field :bool_field, :boolean
+      field :int_field, :integer
+      field :float_field, :float
+      field :string_field, :string
+      field :map_field, :map
+      field :array_field, {:array, :string}
+      field :date_field, :date
+      field :time_field, :time
+      field :utc_datetime_field, :utc_datetime
+      field :naive_datetime_field, :naive_datetime
+
+      timestamps()
+    end
+
+    def changeset(record, attrs) do
+      record
+      |> cast(attrs, [
+        :bool_field, :int_field, :float_field, :string_field,
+        :map_field, :array_field, :date_field, :time_field,
+        :utc_datetime_field, :naive_datetime_field
+      ])
+    end
+  end
+
+  @test_db "z_ecto_libsql_test-type_compat.db"
+
+  setup_all do
+    {:ok, _} = TestRepo.start_link(database: @test_db)
+
+    Ecto.Adapters.SQL.query!(TestRepo, """
+    CREATE TABLE IF NOT EXISTS records (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      bool_field INTEGER,
+      int_field INTEGER,
+      float_field REAL,
+      string_field TEXT,
+      map_field TEXT,
+      array_field TEXT,
+      date_field TEXT,
+      time_field TEXT,
+      utc_datetime_field TEXT,
+      naive_datetime_field TEXT,
+      inserted_at DATETIME,
+      updated_at DATETIME
+    )
+    """)
+
+    on_exit(fn ->
+      EctoLibSql.TestHelpers.cleanup_db_files(@test_db)
+    end)
+
+    :ok
+  end
+
+  test "all field types round-trip correctly" do
+    now_utc = DateTime.utc_now()
+    now_naive = NaiveDateTime.utc_now()
+    today = Date.utc_today()
+    current_time = Time.new!(12, 30, 45)
+
+    attrs = %{
+      bool_field: true,
+      int_field: 42,
+      float_field: 3.14,
+      string_field: "test",
+      map_field: %{"key" => "value"},
+      array_field: ["a", "b", "c"],
+      date_field: today,
+      time_field: current_time,
+      utc_datetime_field: now_utc,
+      naive_datetime_field: now_naive
+    }
+
+    # Insert
+    changeset = Record.changeset(%Record{}, attrs)
+    {:ok, inserted} = TestRepo.insert(changeset)
+
+    IO.puts("\n=== Type Compatibility Test ===")
+    IO.inspect(inserted, label: "Inserted record")
+
+    # Verify inserted struct
+    assert inserted.id != nil
+    assert inserted.bool_field == true
+    assert inserted.int_field == 42
+    assert inserted.float_field == 3.14
+    assert inserted.string_field == "test"
+    assert inserted.map_field == %{"key" => "value"}
+    assert inserted.array_field == ["a", "b", "c"]
+    assert inserted.date_field == today
+    assert inserted.time_field == current_time
+
+    # Query back
+    queried = TestRepo.get(Record, inserted.id)
+    IO.inspect(queried, label: "Queried record")
+
+    # Verify queried struct - all types should match
+    assert queried.id == inserted.id
+    assert queried.bool_field == true, "Boolean should roundtrip"
+    assert queried.int_field == 42, "Integer should roundtrip"
+    assert queried.float_field == 3.14, "Float should roundtrip"
+    assert queried.string_field == "test", "String should roundtrip"
+    assert queried.map_field == %{"key" => "value"}, "Map should roundtrip"
+    assert queried.array_field == ["a", "b", "c"], "Array should roundtrip"
+    assert queried.date_field == today, "Date should roundtrip"
+    assert queried.time_field == current_time, "Time should roundtrip"
+
+    IO.puts("✅ PASS: All types round-trip correctly")
+  end
+end