Add Options parameter to soft delete functions (#187) (#188)

* Add Options parameter to soft delete functions (#187)
- Adds optional opts parameter to soft_delete/2, soft_deleteand soft_delete_all/2
- Added tests to cover the new functionality
- Maintaions backward compatibility with existing code
- Enables use of options like 'prefix' for multi-tenant databases
- Updates function documentation with examples showing options usage

- Adds section to README about using options with soft delete functions

* Fix documentation references to maintain callback compatibility

* Add test for log option in soft_delete_all function (#187)
- Adds test to verify that log option is properly passed to Ecto
- Imported ExUnit.CaptureLog in test module to capture all log output generated within the function passed to it. Returns output as a string to assert against
- Confirms SQL queries are loggged when log: :info is passed
- Removed unnecessary comments
- Further validates that all Ecto options are correctly handled

* Simplify soft delete functions (#187)
- Remove unnecessary case statements and vars in soft_delete functions
- Pass options directly to underlying Ecto functions
- Kept same functionality while better following Elixir style conventions, and improving readability

* Refactor soft delete functions with pipe operator (#188)
- Replace varialbe assignment with pipe operators in soft_delete functions

---------

Co-authored-by: Daniel <[email protected]>

Author: danicodes01

README.md

@@ -117,6 +117,17 @@ post = Repo.get!(Post, 42)
 struct = Repo.soft_delete!(post)
 ```
 
+### Using Options with Soft Delete Functions
+All soft delete functions support the same options as their Ecto counterparts:
+
+```elixir
+# With schema prefix for multi-tenant databases
+Repo.soft_delete(post, prefix: "tenant_abc")
+Repo.soft_delete!(post, prefix: "tenant_abc")
+Repo.soft_delete_all(Post, prefix: "tenant_abc")
+```
+This allows for seamless integration with features like PostgreSQL schema prefixes for multi-tenancy.
+
 `Ecto.SoftDelete.Repo` will also intercept all queries made with the repo and automatically add a clause to filter out soft-deleted rows.
 
 ## Installation

lib/ecto/soft_delete_repo.ex

@@ -18,13 +18,21 @@ defmodule Ecto.SoftDelete.Repo do
   result as second element. The second element is `nil` by default
   unless a `select` is supplied in the update query.
 
+  ## Options
+
+  All options supported by `c:Ecto.Repo.update_all/3` can be used.
+
   ## Examples
 
       MyRepo.soft_delete_all(Post)
       from(p in Post, where: p.id < 10) |> MyRepo.soft_delete_all()
 
+      # With schema prefix for multi-tenant databases
+      MyRepo.soft_delete_all(Post, prefix: "tenant_abc")
+
   """
-  @callback soft_delete_all(queryable :: Ecto.Queryable.t()) :: {integer, nil | [term]}
+  @callback soft_delete_all(queryable :: Ecto.Queryable.t(), opts :: Keyword.t()) ::
+              {integer, nil | [term()]}
 
   @doc """
   Soft deletes a struct.
@@ -33,6 +41,10 @@ defmodule Ecto.SoftDelete.Repo do
   soft deleted or `{:error, changeset}` if there was a validation
   or a known constraint error.
 
+  ## Options
+
+  All options supported by `c:Ecto.Repo.update/2` can be used.
+
   ## Examples
 
       post = MyRepo.get!(Post, 42)
@@ -41,35 +53,44 @@ defmodule Ecto.SoftDelete.Repo do
         {:error, changeset} -> # Something went wrong
       end
 
+      # With schema prefix for multi-tenant databases
+      MyRepo.soft_delete(post, prefix: "tenant_abc")
+
   """
-  @callback soft_delete(struct_or_changeset :: Ecto.Schema.t() | Ecto.Changeset.t()) ::
-              {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
+  @callback soft_delete(
+              struct_or_changeset :: Ecto.Schema.t() | Ecto.Changeset.t(),
+              opts :: Keyword.t()
+            ) :: {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
 
   @doc """
-  Same as `c:soft_delete/1` but returns the struct or raises if the changeset is invalid.
+  Same as `c:soft_delete/2` but returns the struct or raises if the changeset is invalid.
   """
-  @callback soft_delete!(struct_or_changeset :: Ecto.Schema.t() | Ecto.Changeset.t()) ::
-              Ecto.Schema.t()
+  @callback soft_delete!(
+              struct_or_changeset :: Ecto.Schema.t() | Ecto.Changeset.t(),
+              opts :: Keyword.t()
+            ) :: Ecto.Schema.t()
 
   defmacro __using__(_opts) do
     quote do
       import Ecto.Query
       import Ecto.SoftDelete.Query
 
-      def soft_delete_all(queryable) do
-        update_all(queryable, set: [deleted_at: DateTime.utc_now()])
+      def soft_delete_all(queryable, opts \\ []) do
+        set_expr = [set: [deleted_at: DateTime.utc_now()]]
+        update_all(queryable, set_expr, opts)
       end
 
-      def soft_delete(struct_or_changeset) do
+      # Define soft_delete and soft_delete! with options
+      def soft_delete(struct_or_changeset, opts \\ []) do
         struct_or_changeset
         |> Ecto.Changeset.change(deleted_at: DateTime.utc_now())
-        |> update()
+        |> __MODULE__.update(opts)
       end
 
-      def soft_delete!(struct_or_changeset) do
+      def soft_delete!(struct_or_changeset, opts \\ []) do
         struct_or_changeset
         |> Ecto.Changeset.change(deleted_at: DateTime.utc_now())
-        |> update!()
+        |> __MODULE__.update!(opts)
       end
 
       @doc """

test/soft_delete_repo_test.exs

@@ -2,6 +2,7 @@ defmodule Ecto.SoftDelete.Repo.Test do
   use ExUnit.Case
   alias Ecto.SoftDelete.Test.Repo
   import Ecto.Query
+  import ExUnit.CaptureLog
 
   defmodule User do
     use Ecto.Schema
@@ -55,6 +56,18 @@ defmodule Ecto.SoftDelete.Repo.Test do
     end
   end
 
+  describe "soft_delete!/2 with options" do
+    test "should soft delete the queryable and pass options to update!" do
+      user = Repo.insert!(%User{email: "[email protected]"})
+
+      # Test with empty options list
+      assert %User{} = Repo.soft_delete!(user, [])
+
+      assert %DateTime{} =
+               Repo.get_by!(User, [email: "[email protected]"], with_deleted: true).deleted_at
+    end
+  end
+
   describe "soft_delete/1" do
     test "should soft delete the queryable" do
       user = Repo.insert!(%User{email: "[email protected]"})
@@ -75,6 +88,18 @@ defmodule Ecto.SoftDelete.Repo.Test do
     end
   end
 
+  describe "soft_delete/2 with options" do
+    test "should soft delete the queryable and pass options to update" do
+      user = Repo.insert!(%User{email: "[email protected]"})
+
+      # Test with empty options list
+      assert {:ok, %User{}} = Repo.soft_delete(user, [])
+
+      assert %DateTime{} =
+               Repo.get_by!(User, [email: "[email protected]"], with_deleted: true).deleted_at
+    end
+  end
+
   describe "soft_delete_all/1" do
     test "soft deleted the query" do
       Repo.insert!(%User{email: "[email protected]"})
@@ -100,6 +125,36 @@ defmodule Ecto.SoftDelete.Repo.Test do
     end
   end
 
+  describe "soft_delete_all/2 with options" do
+    test "soft deletes the query and passes options to update_all" do
+      Repo.insert!(%User{email: "[email protected]"})
+      Repo.insert!(%User{email: "[email protected]"})
+
+      # Test with empty options list
+      assert Repo.soft_delete_all(User, []) == {2, nil}
+
+      assert User |> Repo.all(with_deleted: true) |> length() == 2
+
+      assert %DateTime{} =
+               Repo.get_by!(User, [email: "[email protected]"], with_deleted: true).deleted_at
+
+      assert %DateTime{} =
+               Repo.get_by!(User, [email: "[email protected]"], with_deleted: true).deleted_at
+    end
+
+    test "soft deletes with log option" do
+      Repo.insert!(%User{email: "[email protected]"})
+
+      log =
+        capture_log(fn ->
+          Repo.soft_delete_all(User, log: :info)
+        end)
+
+      assert log =~ "UPDATE"
+      assert log =~ "deleted_at"
+    end
+  end
+
   describe "prepare_query/3" do
     test "excludes soft deleted records by default" do
       user = Repo.insert!(%User{email: "[email protected]"})