feat: add :or operator for compound field filter with = instead of like

lib/flop/adapter/ecto.ex

@@ -34,7 +34,8 @@ defmodule Flop.Adapter.Ecto do
     :like_and,
     :like_or,
     :ilike_and,
-    :ilike_or
+    :ilike_or,
+    :or
   ]
 
   @backend_options [
@@ -158,7 +159,8 @@ defmodule Flop.Adapter.Ecto do
            :ilike_and,
            :ilike_or,
            :empty,
-           :not_empty
+           :not_empty,
+           :or
          ],
          extra: %{fields: fields, type: :compound}
        }}
@@ -538,6 +540,25 @@ defmodule Flop.Adapter.Ecto do
     end
   end
 
+  defp build_op(
+          schema_struct,
+          %FieldInfo{extra: %{type: :compound, fields: fields}},
+          %Filter{op: :or, value: value}
+        ) do
+    fields = Enum.map(fields, &get_field_info(schema_struct, &1))
+
+    Enum.reduce(fields, false, fn field, inner_dynamic ->
+      dynamic_for_field =
+        build_op(schema_struct, field, %Filter{
+          field: field,
+          op: :==,
+          value: value
+        })
+
+      dynamic([r], ^inner_dynamic or ^dynamic_for_field)
+    end)
+  end
+
   defp build_op(
          schema_struct,
          %FieldInfo{extra: %{type: :compound, fields: fields}},

lib/flop/adapter/ecto/operators.ex

@@ -274,6 +274,17 @@ defmodule Flop.Adapter.Ecto.Operators do
     {fragment, prelude, combinator}
   end
 
+  def op_config(:or) do
+    fragment =
+      quote do
+        field(r, ^var!(field)) == ^var!(value)
+      end
+
+    combinator = :or
+
+    {fragment, nil, combinator}
+  end
+
   defp empty do
     quote do
       is_nil(field(r, ^var!(field))) == ^var!(value)

lib/flop/filter.ex

@@ -96,6 +96,7 @@ defmodule Flop.Filter do
           | :not_ilike
           | :ilike_and
           | :ilike_or
+          | :or
 
   @operators [
     :==,
@@ -118,7 +119,8 @@ defmodule Flop.Filter do
     :ilike,
     :not_ilike,
     :ilike_and,
-    :ilike_or
+    :ilike_or,
+    :or
   ]
 
   @primary_key false

lib/flop/schema.ex

@@ -108,7 +108,7 @@ defprotocol Flop.Schema do
 
   Setting the value to `nil` (default) allows all pagination types.
 
-  See also `t:Flop.option/0`. 
+  See also `t:Flop.option/0`.
 
   ## Alias fields
 
@@ -199,18 +199,18 @@ defprotocol Flop.Schema do
 
   ### Filter operator rules
 
-  - `:=~` `:like` `:not_like` `:like_and` `:like_or` `:ilike` `:not_ilike` `:ilike_and` `:ilike_or`  
+  - `:=~` `:like` `:not_like` `:like_and` `:like_or` `:ilike` `:not_ilike` `:ilike_and` `:ilike_or`
     If a string value is passed it will be split at whitespace
     characters and each segment will be checked separately. If a list of strings is
     passed the individual strings are not split. The filter matches for a value
     if it matches for any of the fields.
-  - `:empty`  
+  - `:empty`
     Matches if all fields of the compound field are `nil`.
-  - `:not_empty`  
+  - `:not_empty`
     Matches if any field of the compound field is not `nil`.
-  - `:==` `:!=` `:<=` `:<` `:>=` `:>` `:in` `:not_in` `:contains` `:not_contains`  
+  - `:==` `:!=` `:<=` `:<` `:>=` `:>` `:in` `:not_in` `:contains` `:not_contains`
     ** These filter operators are ignored for compound fields at the moment.
-    This will be added in a future version.**  
+    This will be added in a future version.**
     The filter value is normalized by splitting the string at whitespaces and
     joining it with a space. The values of all fields of the compound field are
     split by whitespace character and joined with a space, and the resulting
@@ -655,7 +655,8 @@ defprotocol Flop.Schema do
           :ilike_and,
           :ilike_or,
           :empty,
-          :not_empty
+          :not_empty,
+          :or
         ],
         extra: %{type: :compound, fields: [:family_name, :given_name]}
       }

test/adapters/ecto/cases/flop_test.exs

@@ -699,6 +699,23 @@ defmodule Flop.Adapters.Ecto.FlopTest do
       end
     end
 
+    @tag :or
+    property "applies :or operator on compound field" do
+      check all pet_count <- integer(@pet_count_range),
+                pets = insert_list_and_sort(pet_count, :pet_with_owner),
+                field <- member_of([:pet_and_owner_name]),
+                pet <- member_of(pets),
+                value = Pet.get_field(pet, field) do
+        expected = filter_items(pets, field, :or, value)
+
+        assert query_pets_with_owners(%{
+                 filters: [%{field: field, op: :or, value: value}]
+               }) == expected
+
+        checkin_checkout()
+      end
+    end
+
     property "custom field filter" do
       check all pet_count <- integer(@pet_count_range),
                 pets = insert_list_and_sort(pet_count, :pet_with_owner),

test/base/flop/filter_test.exs

@@ -177,7 +177,8 @@ defmodule Flop.FilterTest do
                :ilike_and,
                :ilike_or,
                :empty,
-               :not_empty
+               :not_empty,
+               :or
              ]
     end
   end

test/support/generators.ex

@@ -118,6 +118,9 @@ defmodule Flop.Generators do
   def value_by_field(:owner_name),
     do: string(:alphanumeric, min_length: 1)
 
+  def value_by_field(:pet_and_owner_name),
+    do: string(:alphanumeric, min_length: 1)
+
   def compare_value_by_field(:age), do: integer(1..30)
 
   def compare_value_by_field(:name),

test/support/test_util.ex

@@ -160,6 +160,21 @@ defmodule Flop.TestUtil do
     end)
   end
 
+  defp apply_filter_to_compound_fields(
+         pet,
+         fields,
+         :or,
+         value,
+         ecto_adapter
+       ) do
+    filter_func = matches?(:or, value, ecto_adapter)
+
+    Enum.any?(fields, fn field ->
+      field_info = Flop.Schema.field_info(%Pet{}, field)
+      pet |> get_field(field_info) |> filter_func.()
+    end)
+  end
+
   defp apply_filter_to_compound_fields(pet, fields, op, value, ecto_adapter) do
     filter_func = matches?(op, value, ecto_adapter)
 
@@ -267,6 +282,8 @@ defmodule Flop.TestUtil do
     &Enum.any?(values, fn v -> String.downcase(&1) =~ v end)
   end
 
+  defp matches?(:or, v, _), do: &(&1 == v)
+
   defp empty?(nil), do: true
   defp empty?([]), do: true
   defp empty?(map) when map == %{}, do: true