fix: Compilation with no Ecto support (#79)

Phoenix.Sync should work over HTTP for a bare Plug app

Author: magnetised

.github/workflows/elixir_tests.yml

@@ -77,8 +77,8 @@ jobs:
       - name: Run tests
         run: mix test --trace
 
-  test-as-dep:
-    name: Test installation as a dependency
+  test-as-dep-standalone:
+    name: Test installation as a dependency without Electric or Ecto
     runs-on: ubuntu-latest
     env:
       MIX_ENV: test
@@ -94,7 +94,26 @@ jobs:
         run: mix deps.get && mix deps.compile
 
       - name: Test installation as a dependency
-        run: mix test.as_a_dep
+        run: mix test.as_a_dep.standalone
+
+  test-as-dep-embedded:
+    name: Test installation as a dependency with embedded Electric
+    runs-on: ubuntu-latest
+    env:
+      MIX_ENV: test
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: erlef/setup-beam@v1
+        with:
+          version-type: strict
+          version-file: ".tool-versions"
+
+      - name: Install dependencies
+        run: mix deps.get && mix deps.compile
+
+      - name: Test installation as a dependency
+        run: mix test.as_a_dep.embedded
 
   test-apps:
     name: Test integration apps

lib/phoenix/sync/gateway.ex

@@ -37,7 +37,7 @@ defmodule Phoenix.Sync.Gateway do
     Map.merge(%{"url" => url, "headers" => auth_headers}, shape_params)
   end
 
-  def configuration(%Ecto.Query{} = query, %Client{} = client) do
+  def configuration(query, %Client{} = client) when is_struct(query, Ecto.Query) do
     query
     |> Electric.Client.shape!()
     |> configuration(client)

lib/phoenix/sync/plug.ex

@@ -146,8 +146,6 @@ defmodule Phoenix.Sync.Plug do
   alias Electric.Client.ShapeDefinition
   alias Phoenix.Sync.Gateway
 
-  require Ecto.Query
-
   @valid_ops [:==, :!=, :>, :<, :>=, :<=]
 
   @type table_column :: atom()
@@ -174,7 +172,7 @@ defmodule Phoenix.Sync.Plug do
         %ShapeDefinition{} = shape ->
           %{shape: shape}
 
-        %Ecto.Query{} = query ->
+        query when is_struct(query, Ecto.Query) ->
           %{shape: Electric.Client.shape!(query)}
 
         schema when is_atom(schema) ->
@@ -357,16 +355,24 @@ defmodule Phoenix.Sync.Plug do
     Plug.Conn.assign(conn, :shape, shape)
   end
 
-  for op <- @valid_ops do
-    where =
-      {op, [],
-       [
-         {:field, [], [Macro.var(:q, nil), {:^, [], [Macro.var(:column, nil)]}]},
-         {:^, [], [Macro.var(:value, nil)]}
-       ]}
-
-    defp add_filter(query, var!(column), unquote(op), var!(value)) do
-      Ecto.Query.where(query, [q], unquote(where))
+  if Code.ensure_loaded?(Ecto.Query) do
+    for op <- @valid_ops do
+      where =
+        {op, [],
+         [
+           {:field, [], [Macro.var(:q, nil), {:^, [], [Macro.var(:column, nil)]}]},
+           {:^, [], [Macro.var(:value, nil)]}
+         ]}
+
+      defp add_filter(query, var!(column), unquote(op), var!(value)) do
+        require Ecto.Query
+        Ecto.Query.where(query, [q], unquote(where))
+      end
+    end
+  else
+    defp add_filter(_query, _, _, _) do
+      raise ArgumentError,
+        message: "Ecto.Query is required for dynamic shapes, please add it to your dependencies."
     end
   end
 

lib/phoenix/sync/predefined_shape.ex

@@ -165,15 +165,17 @@ defmodule Phoenix.Sync.PredefinedShape do
     ShapeDefinition.new!(shape_config)
   end
 
-  # we resolve the query at runtime to avoid compile-time dependencies in
-  # router modules
-  defp to_shape_definition(%__MODULE__{query: queryable, shape_config: shape_config}) do
-    try do
-      Electric.Client.EctoAdapter.shape!(queryable, shape_config)
-    rescue
-      e in Protocol.UndefinedError ->
-        raise ArgumentError,
-          message: "Invalid query `#{inspect(queryable)}`: #{e.description}"
+  if Code.ensure_loaded?(Ecto) do
+    # we resolve the query at runtime to avoid compile-time dependencies in
+    # router modules
+    defp to_shape_definition(%__MODULE__{query: queryable, shape_config: shape_config}) do
+      try do
+        Electric.Client.EctoAdapter.shape!(queryable, shape_config)
+      rescue
+        e in Protocol.UndefinedError ->
+          raise ArgumentError,
+            message: "Invalid query `#{inspect(queryable)}`: #{e.description}"
+      end
     end
   end
 end

lib/phoenix/sync/sandbox.ex

@@ -186,11 +186,7 @@ if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
     use Supervisor
 
     alias __MODULE__
-
-    defmodule Error do
-      @moduledoc false
-      defexception [:message]
-    end
+    alias __MODULE__.Error
 
     @type start_opts() :: [{:shared, boolean()}]
 

lib/phoenix/sync/sandbox/error.ex

@@ -0,0 +1,4 @@
+defmodule Phoenix.Sync.Sandbox.Error do
+  @moduledoc false
+  defexception [:message]
+end

lib/phoenix/sync/sandbox/fetch.ex

@@ -1,66 +1,68 @@
-defmodule Phoenix.Sync.Sandbox.Fetch do
-  @moduledoc false
+if Code.ensure_loaded?(Ecto.Adapters.SQL.Sandbox) do
+  defmodule Phoenix.Sync.Sandbox.Fetch do
+    @moduledoc false
 
-  alias Electric.Client
-  alias Electric.Client.Fetch
+    alias Electric.Client
+    alias Electric.Client.Fetch
 
-  require Logger
+    require Logger
 
-  @callback request(Client.t(), Fetch.Request.t(), opts :: Keyword.t()) ::
-              Fetch.Response.t() | {:error, Fetch.Response.t() | term()}
+    @callback request(Client.t(), Fetch.Request.t(), opts :: Keyword.t()) ::
+                Fetch.Response.t() | {:error, Fetch.Response.t() | term()}
 
-  @behaviour Electric.Client.Fetch.Pool
+    @behaviour Electric.Client.Fetch.Pool
 
-  def name(stack_id) do
-    Phoenix.Sync.Sandbox.name({__MODULE__, stack_id})
-  end
+    def name(stack_id) do
+      Phoenix.Sync.Sandbox.name({__MODULE__, stack_id})
+    end
 
-  @impl Electric.Client.Fetch.Pool
-  def request(%Client{} = client, %Fetch.Request{} = request, opts) do
-    {:ok, stack_id} = Keyword.fetch(opts, :stack_id)
+    @impl Electric.Client.Fetch.Pool
+    def request(%Client{} = client, %Fetch.Request{} = request, opts) do
+      {:ok, stack_id} = Keyword.fetch(opts, :stack_id)
 
-    request_id = request_id(client, request, stack_id)
+      request_id = request_id(client, request, stack_id)
 
-    # The monitor process is unique to the request and launches the actual
-    # request as a linked process.
-    #
-    # This coalesces requests, so no matter how many simultaneous
-    # clients we have, we only ever make one request to the backend.
-    {:ok, monitor_pid} = start_monitor(stack_id, request_id, request, client)
+      # The monitor process is unique to the request and launches the actual
+      # request as a linked process.
+      #
+      # This coalesces requests, so no matter how many simultaneous
+      # clients we have, we only ever make one request to the backend.
+      {:ok, monitor_pid} = start_monitor(stack_id, request_id, request, client)
 
-    try do
-      ref = Fetch.Monitor.register(monitor_pid, self())
+      try do
+        ref = Fetch.Monitor.register(monitor_pid, self())
 
-      Fetch.Monitor.wait(ref)
-    catch
-      :exit, {reason, _} ->
-        Logger.debug(fn ->
-          "Request process ended with reason #{inspect(reason)} before we could register. Re-attempting."
-        end)
+        Fetch.Monitor.wait(ref)
+      catch
+        :exit, {reason, _} ->
+          Logger.debug(fn ->
+            "Request process ended with reason #{inspect(reason)} before we could register. Re-attempting."
+          end)
 
-        request(client, request, opts)
+          request(client, request, opts)
+      end
     end
-  end
 
-  defp start_monitor(stack_id, request_id, request, client) do
-    DynamicSupervisor.start_child(
-      name(stack_id),
-      {Electric.Client.Fetch.Monitor, {request_id, request, client}}
-    )
-    |> return_existing()
-  end
+    defp start_monitor(stack_id, request_id, request, client) do
+      DynamicSupervisor.start_child(
+        name(stack_id),
+        {Electric.Client.Fetch.Monitor, {request_id, request, client}}
+      )
+      |> return_existing()
+    end
 
-  defp return_existing({:ok, pid}), do: {:ok, pid}
-  defp return_existing({:error, {:already_started, pid}}), do: {:ok, pid}
-  defp return_existing(error), do: error
+    defp return_existing({:ok, pid}), do: {:ok, pid}
+    defp return_existing({:error, {:already_started, pid}}), do: {:ok, pid}
+    defp return_existing(error), do: error
 
-  defp request_id(%Client{fetch: {fetch_impl, _}}, %Fetch.Request{} = request, stack_id) do
-    {
-      fetch_impl,
-      stack_id,
-      URI.to_string(request.endpoint),
-      request.headers,
-      Fetch.Request.params(request)
-    }
+    defp request_id(%Client{fetch: {fetch_impl, _}}, %Fetch.Request{} = request, stack_id) do
+      {
+        fetch_impl,
+        stack_id,
+        URI.to_string(request.endpoint),
+        request.headers,
+        Fetch.Request.params(request)
+      }
+    end
   end
 end