active_fields 1.1.0 → 2.0.1

data/lib/active_fields/finders/base_finder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class BaseFinder
+      class << self
+        # Define search operation
+        def operation(name, operator:, &block)
+          name = name.to_sym
+          operator = operator.to_sym
+
+          __operations__[name] = {
+            operator: operator.to_sym,
+            block: block,
+          }
+          __operators__[operator] = name
+        end
+
+        # Returns operator for provided search operation name
+        def operator_for(operation_name)
+          __operations__.dig(operation_name.to_sym, :operator)
+        end
+
+        # Returns search operation name for provided operator
+        def operation_for(operator)
+          __operators__[operator.to_sym]
+        end
+
+        # Returns all defined search operations names
+        def operations
+          __operations__.keys
+        end
+
+        # Storage for defined operations. Private.
+        def __operations__
+          @__operations__ ||= {}
+        end
+
+        # Index for finding operation by operator. Private.
+        def __operators__
+          @__operators__ ||= {}
+        end
+      end
+
+      attr_reader :active_field
+
+      def initialize(active_field:)
+        @active_field = active_field
+      end
+
+      # Perform query operation
+      # @param op [String, Symbol] Operation name or operator
+      # @param value [Any] The value to search for
+      def search(op:, value:)
+        op = op.to_sym if op.respond_to?(:to_sym)
+        operation = self.class.__operations__.key?(op) ? op : self.class.__operators__[op]
+        return if operation.nil?
+
+        instance_exec(value, &self.class.__operations__[operation][:block])
+      end
+
+      private
+
+      # Name of the CTE, that is used in queries. It is the original values table name.
+      def cte_name = ActiveFields.config.value_class.table_name
+
+      # Base scope for querying
+      def scope
+        ActiveFields.config.value_class.with(cte_name => active_field.active_values)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/boolean_finder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class BooleanFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("boolean"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("boolean"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::BooleanCaster.new.deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/date_array_finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DateArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_gt, operator: OPS[:any_gt] do |value|
+        scope.where(value_match_any(">", cast(value)))
+      end
+      operation :any_gteq, operator: OPS[:any_gteq] do |value|
+        scope.where(value_match_any(">=", cast(value)))
+      end
+      operation :any_lt, operator: OPS[:any_lt] do |value|
+        scope.where(value_match_any("<", cast(value)))
+      end
+      operation :any_lteq, operator: OPS[:any_lteq] do |value|
+        scope.where(value_match_any("<=", cast(value)))
+      end
+      operation :all_gt, operator: OPS[:all_gt] do |value|
+        scope.where(value_match_all(">", cast(value)))
+      end
+      operation :all_gteq, operator: OPS[:all_gteq] do |value|
+        scope.where(value_match_all(">=", cast(value)))
+      end
+      operation :all_lt, operator: OPS[:all_lt] do |value|
+        scope.where(value_match_all("<", cast(value)))
+      end
+      operation :all_lteq, operator: OPS[:all_lteq] do |value|
+        scope.where(value_match_all("<=", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::DateCaster.new
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@.date() #{operator} $value.date())"
+    end
+  end
+end

data/lib/active_fields/finders/date_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DateFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("date"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("date"), cast(value)))
+      end
+      operation :gt, operator: OPS[:gt] do |value|
+        scope.where(gt(casted_value_field("date"), cast(value)))
+      end
+      operation :gteq, operator: OPS[:gteq] do |value|
+        scope.where(gteq(casted_value_field("date"), cast(value)))
+      end
+      operation :lt, operator: OPS[:lt] do |value|
+        scope.where(lt(casted_value_field("date"), cast(value)))
+      end
+      operation :lteq, operator: OPS[:lteq] do |value|
+        scope.where(lteq(casted_value_field("date"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::DateCaster.new.deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/date_time_array_finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DateTimeArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_gt, operator: OPS[:any_gt] do |value|
+        scope.where(value_match_any(">", cast(value)))
+      end
+      operation :any_gteq, operator: OPS[:any_gteq] do |value|
+        scope.where(value_match_any(">=", cast(value)))
+      end
+      operation :any_lt, operator: OPS[:any_lt] do |value|
+        scope.where(value_match_any("<", cast(value)))
+      end
+      operation :any_lteq, operator: OPS[:any_lteq] do |value|
+        scope.where(value_match_any("<=", cast(value)))
+      end
+      operation :all_gt, operator: OPS[:all_gt] do |value|
+        scope.where(value_match_all(">", cast(value)))
+      end
+      operation :all_gteq, operator: OPS[:all_gteq] do |value|
+        scope.where(value_match_all(">=", cast(value)))
+      end
+      operation :all_lt, operator: OPS[:all_lt] do |value|
+        scope.where(value_match_all("<", cast(value)))
+      end
+      operation :all_lteq, operator: OPS[:all_lteq] do |value|
+        scope.where(value_match_all("<=", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::DateTimeCaster.new(precision: active_field.precision)
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@.timestamp_tz() #{operator} $value.timestamp_tz())"
+    end
+  end
+end

data/lib/active_fields/finders/date_time_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DateTimeFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :gt, operator: OPS[:gt] do |value|
+        scope.where(gt(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :gteq, operator: OPS[:gteq] do |value|
+        scope.where(gteq(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :lt, operator: OPS[:lt] do |value|
+        scope.where(lt(casted_value_field("timestamp"), cast(value)))
+      end
+      operation :lteq, operator: OPS[:lteq] do |value|
+        scope.where(lteq(casted_value_field("timestamp"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::DateTimeCaster.new(precision: active_field.precision).deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/decimal_array_finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DecimalArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_gt, operator: OPS[:any_gt] do |value|
+        scope.where(value_match_any(">", cast(value)))
+      end
+      operation :any_gteq, operator: OPS[:any_gteq] do |value|
+        scope.where(value_match_any(">=", cast(value)))
+      end
+      operation :any_lt, operator: OPS[:any_lt] do |value|
+        scope.where(value_match_any("<", cast(value)))
+      end
+      operation :any_lteq, operator: OPS[:any_lteq] do |value|
+        scope.where(value_match_any("<=", cast(value)))
+      end
+      operation :all_gt, operator: OPS[:all_gt] do |value|
+        scope.where(value_match_all(">", cast(value)))
+      end
+      operation :all_gteq, operator: OPS[:all_gteq] do |value|
+        scope.where(value_match_all(">=", cast(value)))
+      end
+      operation :all_lt, operator: OPS[:all_lt] do |value|
+        scope.where(value_match_all("<", cast(value)))
+      end
+      operation :all_lteq, operator: OPS[:all_lteq] do |value|
+        scope.where(value_match_all("<=", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::DecimalCaster.new(precision: active_field.precision)
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@.number() #{operator} $value.number())"
+    end
+  end
+end

data/lib/active_fields/finders/decimal_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class DecimalFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("decimal"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("decimal"), cast(value)))
+      end
+      operation :gt, operator: OPS[:gt] do |value|
+        scope.where(gt(casted_value_field("decimal"), cast(value)))
+      end
+      operation :gteq, operator: OPS[:gteq] do |value|
+        scope.where(gteq(casted_value_field("decimal"), cast(value)))
+      end
+      operation :lt, operator: OPS[:lt] do |value|
+        scope.where(lt(casted_value_field("decimal"), cast(value)))
+      end
+      operation :lteq, operator: OPS[:lteq] do |value|
+        scope.where(lteq(casted_value_field("decimal"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::DecimalCaster.new(precision: active_field.precision).deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/enum_array_finder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class EnumArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::EnumCaster.new
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@ #{operator} $value)"
+    end
+  end
+end

data/lib/active_fields/finders/enum_finder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class EnumFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("text"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("text"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::EnumCaster.new.deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/integer_array_finder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class IntegerArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_gt, operator: OPS[:any_gt] do |value|
+        scope.where(value_match_any(">", cast(value)))
+      end
+      operation :any_gteq, operator: OPS[:any_gteq] do |value|
+        scope.where(value_match_any(">=", cast(value)))
+      end
+      operation :any_lt, operator: OPS[:any_lt] do |value|
+        scope.where(value_match_any("<", cast(value)))
+      end
+      operation :any_lteq, operator: OPS[:any_lteq] do |value|
+        scope.where(value_match_any("<=", cast(value)))
+      end
+      operation :all_gt, operator: OPS[:all_gt] do |value|
+        scope.where(value_match_all(">", cast(value)))
+      end
+      operation :all_gteq, operator: OPS[:all_gteq] do |value|
+        scope.where(value_match_all(">=", cast(value)))
+      end
+      operation :all_lt, operator: OPS[:all_lt] do |value|
+        scope.where(value_match_all("<", cast(value)))
+      end
+      operation :all_lteq, operator: OPS[:all_lteq] do |value|
+        scope.where(value_match_all("<=", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::IntegerCaster.new
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@ #{operator} $value)"
+    end
+  end
+end

data/lib/active_fields/finders/integer_finder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class IntegerFinder < SingularFinder
+      operation :eq, operator: OPS[:eq] do |value|
+        scope.where(eq(casted_value_field("bigint"), cast(value)))
+      end
+      operation :not_eq, operator: OPS[:not_eq] do |value|
+        scope.where(not_eq(casted_value_field("bigint"), cast(value)))
+      end
+      operation :gt, operator: OPS[:gt] do |value|
+        scope.where(gt(casted_value_field("bigint"), cast(value)))
+      end
+      operation :gteq, operator: OPS[:gteq] do |value|
+        scope.where(gteq(casted_value_field("bigint"), cast(value)))
+      end
+      operation :lt, operator: OPS[:lt] do |value|
+        scope.where(lt(casted_value_field("bigint"), cast(value)))
+      end
+      operation :lteq, operator: OPS[:lteq] do |value|
+        scope.where(lteq(casted_value_field("bigint"), cast(value)))
+      end
+
+      private
+
+      def cast(value)
+        Casters::IntegerCaster.new.deserialize(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/singular_finder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class SingularFinder < BaseFinder
+      private
+
+      # Arel node for `active_fields.value_meta->>const`
+      def value_field_text
+        Arel::Nodes::InfixOperation.new(
+          "->>",
+          Arel::Table.new(cte_name)[:value_meta],
+          Arel::Nodes.build_quoted("const"),
+        )
+      end
+
+      # Arel node with stored value casted to provided type
+      # E.g. `CAST active_fields.value_meta->>const AS bigint`
+      def casted_value_field(to)
+        Arel::Nodes::NamedFunction.new("CAST", [value_field_text.as(to)])
+      end
+
+      # Equal operation, that respects boolean and NULL values
+      def eq(target, value)
+        if value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(NilClass)
+          Arel::Nodes::InfixOperation.new("IS", target, Arel::Nodes.build_quoted(value))
+        else
+          target.eq(value)
+        end
+      end
+
+      # Not equal operation, that respects boolean and NULL values
+      def not_eq(target, value)
+        if value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(NilClass)
+          Arel::Nodes::InfixOperation.new("IS NOT", target, Arel::Nodes.build_quoted(value))
+        else
+          # Comparison with NULL always returns NULL.
+          # NOT NULL is always NULL as well.
+          # We expect them not to be equal to any provided value except TRUE, FALSE and NULL.
+          # So we should search for NULL values too.
+          target.not_eq(value).or(target.eq(nil))
+        end
+      end
+
+      # Greater than operation
+      def gt(target, value)
+        target.gt(value)
+      end
+
+      # Greater than or equal to operation
+      def gteq(target, value)
+        target.gteq(value)
+      end
+
+      # Less than operation
+      def lt(target, value)
+        target.lt(value)
+      end
+
+      # Less than or equal to operation
+      def lteq(target, value)
+        target.lteq(value)
+      end
+    end
+  end
+end

data/lib/active_fields/finders/text_array_finder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveFields
+  module Finders
+    class TextArrayFinder < ArrayFinder
+      operation :include, operator: OPS[:include] do |value|
+        scope.where(value_match_any("==", cast(value)))
+      end
+      operation :not_include, operator: OPS[:not_include] do |value|
+        scope.where.not(value_match_any("==", cast(value)))
+      end
+      operation :any_start_with, operator: OPS[:any_start_with] do |value|
+        scope.where(value_match_any("starts with", cast(value)))
+      end
+      operation :all_start_with, operator: OPS[:all_start_with] do |value|
+        scope.where(value_match_all("starts with", cast(value)))
+      end
+      operation :size_eq, operator: OPS[:size_eq] do |value|
+        scope.where(value_size_eq(value))
+      end
+      operation :size_not_eq, operator: OPS[:size_not_eq] do |value|
+        scope.where(value_size_not_eq(value))
+      end
+      operation :size_gt, operator: OPS[:size_gt] do |value|
+        scope.where(value_size_gt(value))
+      end
+      operation :size_gteq, operator: OPS[:size_gteq] do |value|
+        scope.where(value_size_gteq(value))
+      end
+      operation :size_lt, operator: OPS[:size_lt] do |value|
+        scope.where(value_size_lt(value))
+      end
+      operation :size_lteq, operator: OPS[:size_lteq] do |value|
+        scope.where(value_size_lteq(value))
+      end
+
+      private
+
+      def cast(value)
+        caster = Casters::TextCaster.new
+        caster.serialize(caster.deserialize(value))
+      end
+
+      def jsonpath(operator) = "$[*] ? (@ #{operator} $value)"
+    end
+  end
+end