just fake txids completely

Author: magnetised

lib/phoenix/sync/sandbox.ex

@@ -252,7 +252,6 @@ if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
 
           # give the inspector access to the sandboxed connection
           Ecto.Adapters.SQL.Sandbox.allow(repo, owner, Sandbox.Inspector.name(stack_id))
-          :ok = Sandbox.Producer.sync(stack_id)
 
           # mark the stack as ready
           Electric.StatusMonitor.mark_pg_lock_acquired(stack_id, owner)

lib/phoenix/sync/sandbox/inspector.ex

@@ -36,10 +36,6 @@ if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
       Phoenix.Sync.Sandbox.name({__MODULE__, stack_id})
     end
 
-    def current_xmax(stack_id) do
-      GenServer.call(name(stack_id), :current_xmax)
-    end
-
     @impl GenServer
     def init(args) do
       {:ok, stack_id} = Keyword.fetch(args, :stack_id)
@@ -73,16 +69,6 @@ if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
       }
     end
 
-    def handle_call(:current_xmax, _from, state) do
-      reply =
-        with {:ok, %{rows: [[xmax]]}} <-
-               Postgrex.query(pool(state), "SELECT pg_snapshot_xmax(pg_current_snapshot())", []) do
-          {:ok, xmax}
-        end
-
-      {:reply, reply, state}
-    end
-
     defp pool(state) do
       %{pid: pool} = Ecto.Adapter.lookup_meta(state.repo.get_dynamic_repo())
       pool

lib/phoenix/sync/sandbox/producer.ex

@@ -33,10 +33,6 @@ if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
       GenServer.cast(name(stack_id), {:emit_changes, changes})
     end
 
-    def sync(stack_id) do
-      GenServer.call(name(stack_id), :sync)
-    end
-
     def name(stack_id) do
       Phoenix.Sync.Sandbox.name({__MODULE__, stack_id})
     end
@@ -50,18 +46,6 @@ if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
       {:ok, state}
     end
 
-    # get the current xmax from pg so that our change events are properly ordered
-    # after the initial sync
-    # has to come after start up and after we've allowed the inspector access to the
-    # sandboxed connection
-    def handle_call(:sync, _from, state) do
-      with {:ok, xmax} <- Phoenix.Sync.Sandbox.Inspector.current_xmax(state.stack_id) do
-        {:reply, :ok, Map.put(state, :txid, xmax + 1000)}
-      else
-        error -> {:reply, error, state}
-      end
-    end
-
     def handle_cast({:emit_changes, changes}, %{txid: txid, stack_id: stack_id} = state) do
       {msgs, next_txid} =
         changes

lib/phoenix/sync/sandbox/stack.ex

@@ -42,16 +42,7 @@ if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
       Postgrex.transaction(
         db_pool,
         fn conn ->
-          # %{rows: [[pg_snapshot]]} = Postgrex.query!(conn, "SELECT pg_current_snapshot()", [])
-
-          %{rows: [[xmin, xmax]]} =
-            Postgrex.query!(
-              conn,
-              "SELECT pg_snapshot_xmin(pg_current_snapshot()), pg_snapshot_xmax(pg_current_snapshot())",
-              []
-            )
-
-          GenServer.cast(parent, {:pg_snapshot_known, shape_handle, {xmin, xmax, []}})
+          GenServer.cast(parent, {:pg_snapshot_known, shape_handle, {1000, 1100, []}})
 
           # Enforce display settings *before* querying initial data to maintain consistent
           # formatting between snapshot and live log entries.