[#249] Remove default transaction implementation from core library

Author: cabol

CHANGELOG.md

@@ -20,6 +20,18 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
   defaults.
   [#248](https://github.com/elixir-nebulex/nebulex/issues/248).
 
+### Backwards incompatible changes
+
+- [Nebulex.Adapter.Transaction] The default transaction implementation has been
+  removed from the core Nebulex library. Each adapter is now responsible for
+  providing its own transaction implementation tailored to its specific needs.
+  This change keeps the core library more generic and allows adapters to
+  optimize transaction handling for their particular use cases (e.g., local
+  ETS-based locking for single-node caches vs. distributed locking for
+  multi-node setups). Adapters that support transactions must implement
+  the `Nebulex.Adapter.Transaction` behaviour independently.
+  [#249](https://github.com/elixir-nebulex/nebulex/issues/249).
+
 ### Enhancements
 
 ## [v3.0.0-rc.2](https://github.com/elixir-nebulex/nebulex/tree/v3.0.0-rc.2) (2025-12-07)

lib/nebulex/adapter/transaction.ex

@@ -1,43 +1,6 @@
 defmodule Nebulex.Adapter.Transaction do
   @moduledoc """
   Specifies the adapter Transaction API.
-
-  ## Default implementation
-
-  This module also provides a default implementation which uses the Erlang
-  library `:global`.
-
-  This implementation accepts the following options:
-
-  #{Nebulex.Adapter.Transaction.Options.options_docs()}
-
-  Let's see an example:
-
-      MyCache.transaction fn ->
-        counter = MyCache.get(:counter)
-        MyCache.set(:counter, counter + 1)
-      end
-
-  Locking only the involved key (recommended):
-
-      MyCache.transaction(
-        fn ->
-          counter = MyCache.get(:counter)
-          MyCache.set(:counter, counter + 1)
-        end,
-        [keys: [:counter]]
-      )
-
-      MyCache.transaction(
-        fn ->
-          alice = MyCache.get(:alice)
-          bob = MyCache.get(:bob)
-          MyCache.set(:alice, %{alice | balance: alice.balance + 100})
-          MyCache.set(:bob, %{bob | balance: bob.balance + 100})
-        end,
-        [keys: [:alice, :bob]]
-      )
-
   """
 
   @doc """
@@ -66,109 +29,4 @@ defmodule Nebulex.Adapter.Transaction do
   """
   @callback in_transaction?(Nebulex.Adapter.adapter_meta(), Nebulex.Cache.opts()) ::
               Nebulex.Cache.ok_error_tuple(boolean())
-
-  alias Nebulex.Adapter.Transaction.Options
-
-  import Nebulex.Utils, only: [wrap_ok: 1, wrap_error: 2]
-
-  @doc false
-  defmacro __using__(_opts) do
-    quote do
-      @behaviour Nebulex.Adapter.Transaction
-
-      @impl true
-      defdelegate transaction(adapter_meta, fun, opts), to: unquote(__MODULE__)
-
-      @impl true
-      defdelegate in_transaction?(adapter_meta, opts), to: unquote(__MODULE__)
-
-      defoverridable transaction: 3, in_transaction?: 2
-    end
-  end
-
-  @doc false
-  def transaction(%{cache: cache, pid: pid} = adapter_meta, fun, opts) do
-    opts = Options.validate!(opts)
-
-    adapter_meta
-    |> do_in_transaction?()
-    |> do_transaction(
-      pid,
-      adapter_meta[:name] || cache,
-      Keyword.fetch!(opts, :keys),
-      Keyword.get(opts, :nodes, [node()]),
-      Keyword.fetch!(opts, :retries),
-      fun
-    )
-  end
-
-  @doc false
-  def in_transaction?(adapter_meta, _opts) do
-    wrap_ok do_in_transaction?(adapter_meta)
-  end
-
-  ## Helpers
-
-  defp do_in_transaction?(%{pid: pid}) do
-    !!Process.get({pid, self()})
-  end
-
-  defp do_transaction(true, _pid, _name, _keys, _nodes, _retries, fun) do
-    {:ok, fun.()}
-  end
-
-  defp do_transaction(false, pid, name, keys, nodes, retries, fun) do
-    ids = lock_ids(name, keys)
-
-    case set_locks(ids, nodes, retries) do
-      true ->
-        try do
-          _ = Process.put({pid, self()}, %{keys: keys, nodes: nodes})
-
-          {:ok, fun.()}
-        after
-          _ = Process.delete({pid, self()})
-
-          del_locks(ids, nodes)
-        end
-
-      false ->
-        wrap_error Nebulex.Error,
-          reason: :transaction_aborted,
-          cache: name,
-          nodes: nodes,
-          cache: name
-    end
-  end
-
-  defp set_locks(ids, nodes, retries) do
-    maybe_set_lock = fn id, {:ok, acc} ->
-      case :global.set_lock(id, nodes, retries) do
-        true -> {:cont, {:ok, [id | acc]}}
-        false -> {:halt, {:error, acc}}
-      end
-    end
-
-    case Enum.reduce_while(ids, {:ok, []}, maybe_set_lock) do
-      {:ok, _} ->
-        true
-
-      {:error, locked_ids} ->
-        :ok = del_locks(locked_ids, nodes)
-
-        false
-    end
-  end
-
-  defp del_locks(ids, nodes) do
-    Enum.each(ids, &:global.del_lock(&1, nodes))
-  end
-
-  defp lock_ids(name, []) do
-    [{name, self()}]
-  end
-
-  defp lock_ids(name, keys) do
-    Enum.map(keys, &{{name, &1}, self()})
-  end
 end

lib/nebulex/adapter/transaction/options.ex

@@ -70,9 +70,7 @@ defmodule Nebulex.Adapters.Nil do
   @behaviour Nebulex.Adapter
   @behaviour Nebulex.Adapter.KV
   @behaviour Nebulex.Adapter.Queryable
-
-  # Inherit default transaction implementation
-  use Nebulex.Adapter.Transaction
+  @behaviour Nebulex.Adapter.Transaction
 
   # Inherit default info implementation
   use Nebulex.Adapters.Common.Info
@@ -169,6 +167,18 @@ defmodule Nebulex.Adapters.Nil do
     with_hooks(opts, {:ok, Stream.each([], & &1)})
   end
 
+  ## Nebulex.Adapter.Transaction
+
+  @impl true
+  def transaction(_, fun, opts) do
+    with_hooks(opts, {:ok, fun.()})
+  end
+
+  @impl true
+  def in_transaction?(_, opts) do
+    with_hooks(opts, {:ok, false})
+  end
+
   ## Private functions
 
   defp with_hooks([], result) do

lib/nebulex/adapters/nil.ex

@@ -108,12 +108,6 @@ defmodule Nebulex.Adapters.NilTest do
 
     test "in_transaction?", %{cache: cache} do
       assert cache.in_transaction?() == {:ok, false}
-
-      cache.transaction(fn ->
-        :ok = cache.put(1, 11)
-
-        assert cache.in_transaction?() == {:ok, true}
-      end)
     end
   end
 

test/nebulex/adapters/nil_test.exs

@@ -8,6 +8,23 @@ defmodule Nebulex.Adapters.CacheTest do
 
   setup_with_dynamic_cache Nebulex.TestCache.Cache, __MODULE__
 
+  describe "error" do
+    test "because cache is stopped", %{cache: cache, name: name} do
+      :ok = stop_supervised!(name)
+
+      ops = [
+        fn -> cache.put(1, 13) end,
+        fn -> cache.put!(1, 13) end,
+        fn -> cache.get!(1) end,
+        fn -> cache.delete!(1) end
+      ]
+
+      for fun <- ops do
+        assert_raise Nebulex.CacheNotFoundError, ~r/unable to find cache: #{inspect(name)}/, fun
+      end
+    end
+  end
+
   describe "KV:" do
     test "get_and_update", %{cache: cache} do
       fun = fn
@@ -176,19 +193,35 @@ defmodule Nebulex.Adapters.CacheTest do
     end
   end
 
-  describe "error" do
-    test "because cache is stopped", %{cache: cache, name: name} do
-      :ok = stop_supervised!(name)
+  describe "transaction" do
+    test "aborted", %{name: name, cache: cache} do
+      key = {name, :aborted}
 
-      ops = [
-        fn -> cache.put(1, 13) end,
-        fn -> cache.put!(1, 13) end,
-        fn -> cache.get!(1) end,
-        fn -> cache.delete!(1) end
-      ]
+      Task.start_link(fn ->
+        _ = cache.put_dynamic_cache(name)
 
-      for fun <- ops do
-        assert_raise Nebulex.CacheNotFoundError, ~r/unable to find cache: #{inspect(name)}/, fun
+        cache.transaction(
+          fn ->
+            :ok = cache.put(key, true)
+
+            Process.sleep(1100)
+          end,
+          keys: [key],
+          retries: 1
+        )
+      end)
+
+      :ok = Process.sleep(200)
+
+      assert_raise Nebulex.Error, ~r/transaction aborted\n\nError metadata:/, fn ->
+        {:error, %Nebulex.Error{} = reason} =
+          cache.transaction(
+            fn -> cache.get(key) end,
+            keys: [key],
+            retries: 1
+          )
+
+        raise reason
       end
     end
   end