forest_admin_datasource_toolkit 1.0.0.pre.beta.21

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/nodes/condition_tree_leaf.rb

@@ -0,0 +1,144 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        module Nodes
+          class ConditionTreeLeaf < ConditionTree
+            include ForestAdminDatasourceToolkit::Utils
+            include ForestAdminDatasourceToolkit::Exceptions
+
+            attr_reader :field, :operator, :value
+
+            def initialize(field, operator, value = nil)
+              @field = field
+              @operator = operator
+              @value = value
+              valid_operator(@operator) if @operator
+              super()
+            end
+
+            def to_h
+              {
+                field: @field,
+                operator: @operator,
+                value: @value
+              }
+            end
+
+            def valid_operator(value)
+              return if Operators.exist?(value)
+
+              raise ForestException, "Invalid operators, the #{value} operator does not exist."
+            end
+
+            def inverse
+              return override(operator: "Not_#{@operator}") if Operators.exist?("Not_#{@operator}")
+              return override(operator: @operator[4..]) if @operator.start_with?('Not')
+
+              case @operator
+              when 'Blank'
+                override(operator: 'Present')
+              when 'Present'
+                override(operator: 'Blank')
+              else
+                raise ForestException, "Operator: #{@operator} cannot be inverted."
+              end
+            end
+
+            def replace_leafs
+              result = yield(self)
+              if result.nil?
+                nil
+              elsif result.is_a?(ConditionTree)
+                result
+              else
+                ConditionTreeFactory.from_array(result)
+              end
+            end
+
+            def match(record, collection, timezone)
+              field_value = Record.field_value(record, @field)
+              column_type = Utils::Collection.get_field_schema(collection, @field).column_type
+
+              supported = [
+                Operators::IN,
+                Operators::EQUAL,
+                Operators::LESS_THAN,
+                Operators::GREATER_THAN,
+                Operators::MATCH,
+                Operators::STARTS_WITH,
+                Operators::ENDS_WITH,
+                Operators::LONGER_THAN,
+                Operators::SHORTER_THAN,
+                Operators::INCLUDES_ALL,
+                Operators::NOT_IN,
+                Operators::NOT_EQUAL,
+                Operators::NOT_CONTAINS
+              ]
+
+              case @operator
+              when Operators::IN
+                Array(@value).include?(field_value)
+              when Operators::EQUAL
+                field_value == @value
+              when Operators::LESS_THAN
+                field_value < @value
+              when Operators::GREATER_THAN
+                field_value > @value
+              when Operators::MATCH
+                field_value.is_a?(String) && @value.match(field_value)
+              when Operators::STARTS_WITH
+                field_value.is_a?(String) && field_value.start_with?(@value)
+              when Operators::ENDS_WITH
+                field_value.is_a?(String) && field_value.end_with?(@value)
+              when Operators::LONGER_THAN
+                field_value.is_a?(String) && field_value.length > @value
+              when Operators::SHORTER_THAN
+                field_value.is_a?(String) && field_value.length < @value
+              when Operators::INCLUDES_ALL
+                Array(@value).all? { |v| field_value.include?(v) }
+              when Operators::NOT_IN, Operators::NOT_EQUAL, Operators::NOT_CONTAINS
+                !inverse.match(record, collection, timezone)
+              else
+                ConditionTreeEquivalent.get_equivalent_tree(
+                  self,
+                  supported,
+                  column_type,
+                  timezone
+                )&.match(record, collection, timezone)
+              end
+            end
+
+            def for_each_leaf
+              yield(self)
+            end
+
+            def every_leaf
+              yield(self)
+            end
+
+            def some_leaf
+              yield(self)
+            end
+
+            def projection
+              Projection.new([@field])
+            end
+
+            def override(args)
+              ConditionTreeLeaf.new(
+                args[:field] || @field,
+                args[:operator] || @operator,
+                args[:value] || @value
+              )
+            end
+
+            def use_interval_operator
+              Operators.interval_operators.include?(@operator)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/operators.rb

@@ -0,0 +1,100 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        class Operators
+          EQUAL = 'Equal'.freeze
+          NOT_EQUAL = 'Not_Equal'.freeze
+          LESS_THAN = 'Less_Than'.freeze
+          GREATER_THAN = 'Greater_Than'.freeze
+          MATCH = 'Match'.freeze
+          LIKE = 'Like'.freeze
+          I_LIKE = 'ILike'.freeze
+          NOT_CONTAINS = 'Not_Contains'.freeze
+          CONTAINS = 'Contains'.freeze
+          I_CONTAINS = 'IContains'.freeze
+          LONGER_THAN = 'Longer_Than'.freeze
+          SHORTER_THAN = 'Shorter_Than'.freeze
+          INCLUDES_ALL = 'Includes_All'.freeze
+          PRESENT = 'Present'.freeze
+          BLANK = 'Blank'.freeze
+          IN = 'In'.freeze
+          NOT_IN = 'Not_In'.freeze
+          STARTS_WITH = 'Starts_With'.freeze
+          I_STARTS_WITH = 'IStarts_With'.freeze
+          ENDS_WITH = 'Ends_With'.freeze
+          I_ENDS_WITH = 'IEnds_With'.freeze
+          MISSING = 'Missing'.freeze
+          BEFORE = 'Before'.freeze
+          AFTER = 'After'.freeze
+          AFTER_X_HOURS_AGO = 'After_X_Hours_Ago'.freeze
+          BEFORE_X_HOURS_AGO = 'Before_X_Hours_Ago'.freeze
+          FUTURE = 'Future'.freeze
+          PAST = 'Past'.freeze
+          TODAY = 'Today'.freeze
+          YESTERDAY = 'Yesterday'.freeze
+          PREVIOUS_WEEK = 'Previous_Week'.freeze
+          PREVIOUS_MONTH = 'Previous_Month'.freeze
+          PREVIOUS_QUARTER = 'Previous_Quarter'.freeze
+          PREVIOUS_YEAR = 'Previous_Year'.freeze
+          PREVIOUS_WEEK_TO_DATE = 'Previous_Week_To_Date'.freeze
+          PREVIOUS_MONTH_TO_DATE = 'Previous_Month_To_Date'.freeze
+          PREVIOUS_QUARTER_TO_DATE = 'Previous_Quarter_To_Date'.freeze
+          PREVIOUS_YEAR_TO_DATE = 'Previous_Year_To_Date'.freeze
+          PREVIOUS_X_DAYS = 'Previous_X_Days'.freeze
+          PREVIOUS_X_DAYS_TO_DATE = 'Previous_X_Days_To_Date'.freeze
+
+          def self.all
+            constants
+          end
+
+          def self.exist?(operator_value)
+            case operator_value
+            when 'ILike'
+              operator_value = 'I_LIKE'
+            when 'IContains'
+              operator_value = 'I_CONTAINS'
+            when 'IStarts_With'
+              operator_value = 'I_STARTS_WITH'
+            when 'IEnds_With'
+              operator_value = 'I_ENDS_WITH'
+            end
+
+            all.include?(operator_value.upcase.to_sym)
+          end
+
+          def self.interval_operators
+            [
+              self::TODAY,
+              self::YESTERDAY,
+              self::PREVIOUS_MONTH,
+              self::PREVIOUS_QUARTER,
+              self::PREVIOUS_WEEK,
+              self::PREVIOUS_YEAR,
+              self::PREVIOUS_MONTH_TO_DATE,
+              self::PREVIOUS_QUARTER_TO_DATE,
+              self::PREVIOUS_WEEK_TO_DATE,
+              self::PREVIOUS_X_DAYS_TO_DATE,
+              self::PREVIOUS_X_DAYS,
+              self::PREVIOUS_YEAR_TO_DATE
+            ]
+          end
+
+          def self.unique_operators
+            [
+              self::EQUAL,
+              self::NOT_EQUAL,
+              self::LESS_THAN,
+              self::GREATER_THAN,
+              self::MATCH,
+              self::NOT_CONTAINS,
+              self::LONGER_THAN,
+              self::SHORTER_THAN,
+              self::INCLUDES_ALL
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/transforms/comparisons.rb

@@ -0,0 +1,123 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        module Transforms
+          class Comparisons
+            include ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes
+
+            def self.transforms
+              {
+                Operators::BLANK => [
+                  {
+                    depends_on: [Operators::IN],
+                    for_types: ['String'],
+                    replacer: ->(leaf) { leaf.override({ operator: Operators::IN, value: [nil, ''] }) }
+                  },
+                  {
+                    depends_on: [Operators::MISSING],
+                    replacer: ->(leaf) { leaf.override({ operator: Operators::MISSING }) }
+                  }
+                ],
+                Operators::MISSING => [
+                  {
+                    depends_on: [Operators::EQUAL],
+                    replacer: ->(leaf) { leaf.override({ operator: Operators::EQUAL, value: nil }) }
+                  }
+                ],
+                Operators::PRESENT => [
+                  {
+                    depends_on: [Operators::NOT_IN],
+                    for_types: ['String'],
+                    replacer: ->(leaf) { leaf.override({ operator: Operators::NOT_IN, value: [nil, ''] }) }
+                  },
+                  {
+                    depends_on: [Operators::NOT_EQUAL],
+                    replacer: ->(leaf) { leaf.override({ operator: Operators::NOT_EQUAL, value: nil }) }
+                  }
+                ],
+                Operators::EQUAL => [
+                  {
+                    depends_on: [Operators::IN],
+                    replacer: ->(leaf) { leaf.override({ operator: Operators::IN, value: [leaf.value] }) }
+                  }
+                ],
+                Operators::IN => [
+                  {
+                    depends_on: [Operators::EQUAL, Operators::MATCH],
+                    for_types: ['String'],
+                    replacer: lambda { |leaf|
+                      values = leaf.value
+                      conditions = []
+
+                      [nil, ''].each do |value|
+                        if values.include?(value)
+                          conditions.push(ConditionTreeLeaf.new(leaf.field, Operators::EQUAL, value))
+                        end
+                      end
+
+                      if values.any? { |value| !value.nil? && value != '' }
+                        escaped = values.filter { |value| !value.nil? && value != '' }
+
+                        conditions.push(ConditionTreeLeaf.new(leaf.field, Operators::MATCH,
+                                                              "/(#{escaped.join("|")})/g"))
+                      end
+
+                      ConditionTreeFactory.union(conditions)
+                    }
+                  },
+                  {
+                    depends_on: [Operators::EQUAL],
+                    replacer: lambda { |leaf|
+                      ConditionTreeFactory.union(
+                        leaf.value.map { |item| leaf.override({ operator: Operators::EQUAL, value: item }) }
+                      )
+                    }
+                  }
+                ],
+                Operators::NOT_EQUAL => [
+                  {
+                    depends_on: [Operators::NOT_IN],
+                    replacer: ->(leaf) { leaf.override({ operator: Operators::NOT_IN, value: [leaf.value] }) }
+                  }
+                ],
+                Operators::NOT_IN => [
+                  {
+                    depends_on: [Operators::NOT_EQUAL, Operators::MATCH],
+                    for_types: ['String'],
+                    replacer: lambda { |leaf|
+                      values = leaf.value
+                      conditions = []
+
+                      [nil, ''].each do |value|
+                        if values.include?(value)
+                          conditions.push(ConditionTreeLeaf.new(leaf.field, Operators::NOT_EQUAL, value))
+                        end
+                      end
+
+                      if values.any? { |value| !value.nil? && value != '' }
+                        escaped = values.filter { |value| !value.nil? && value != '' }
+                        conditions.push(ConditionTreeLeaf.new(leaf.field, Operators::MATCH,
+                                                              "/(?!(#{escaped.join("|")}))/g"))
+                      end
+
+                      ConditionTreeFactory.intersect(conditions)
+                    }
+                  },
+                  {
+                    depends_on: [Operators::NOT_EQUAL],
+                    replacer: lambda { |leaf|
+                      ConditionTreeFactory.intersect(
+                        leaf.value.map { |item| leaf.override({ operator: Operators::NOT_EQUAL, value: item }) }
+                      )
+                    }
+                  }
+                ]
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/transforms/pattern.rb

@@ -0,0 +1,48 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        module Transforms
+          class Pattern
+            def self.likes(get_pattern, case_sensitive)
+              operator = case_sensitive ? Operators::LIKE : Operators::I_LIKE
+
+              {
+                dependsOn: [operator],
+                forTypes: ['String'],
+                replacer: ->(leaf) { leaf.override(operator: operator, value: get_pattern.call(leaf.value)) }
+              }
+            end
+
+            def self.match(case_sensitive)
+              {
+                dependsOn: [Operators::MATCH],
+                forTypes: ['String'],
+                replacer: lambda { |leaf|
+                  regex = leaf.value.gsub(/([\.\\\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:\-])/, '\\\\\1')
+                  regex.gsub!('%', '.*')
+                  regex.tr!('_', '.')
+
+                  leaf.override(operator: Operators::MATCH, value: "/^#{regex}$/#{case_sensitive ? "" : "i"}")
+                }
+              }
+            end
+
+            def self.transforms
+              {
+                Operators::CONTAINS => [likes(->(value) { "%#{value}%" }, true)],
+                Operators::STARTS_WITH => [likes(->(value) { "#{value}%" }, true)],
+                Operators::ENDS_WITH => [likes(->(value) { "%#{value}" }, true)],
+                Operators::I_CONTAINS => [likes(->(value) { "%#{value}%" }, false)],
+                Operators::I_STARTS_WITH => [likes(->(value) { "#{value}%" }, false)],
+                Operators::I_ENDS_WITH => [likes(->(value) { "%#{value}" }, false)],
+                Operators::I_LIKE => [match(false)],
+                Operators::LIKE => [match(true)]
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/transforms/times.rb

@@ -0,0 +1,112 @@
+require 'active_support/all'
+require 'active_support/core_ext/numeric/time'
+
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      module ConditionTree
+        module Transforms
+          class Times
+            def self.format(value)
+              value.in_time_zone('UTC').iso8601
+            end
+
+            def self.compare(operator)
+              {
+                dependsOn: [operator],
+                forTypes: ['Date', 'Dateonly'],
+                replacer: lambda { |leaf, tz|
+                  leaf.override(operator: operator, value: format(yield(Time.now.in_time_zone(tz), leaf.value)))
+                }
+              }
+            end
+
+            def self.interval(start_fn, end_fn)
+              {
+                dependsOn: [Operators::LESS_THAN, Operators::GREATER_THAN],
+                forTypes: ['Date', 'Dateonly'],
+                replacer: lambda do |leaf, tz|
+                  value_greater_than = if leaf.value.nil?
+                                         format(start_fn.call(Time.now.in_time_zone(tz)))
+                                       else
+                                         format(start_fn.call(
+                                                  Time.now.in_time_zone(tz), leaf.value
+                                                ))
+                                       end
+                  value_less_than = if leaf.value.nil?
+                                      format(end_fn.call(Time.now.in_time_zone(tz)))
+                                    else
+                                      format(end_fn.call(
+                                               Time.now.in_time_zone(tz), leaf.value
+                                             ))
+                                    end
+
+                  ConditionTreeFactory.intersect(
+                    [
+                      leaf.override(operator: Operators::GREATER_THAN, value: value_greater_than),
+                      leaf.override(operator: Operators::LESS_THAN, value: value_less_than)
+                    ]
+                  )
+                end
+              }
+            end
+
+            def self.previous_interval(duration)
+              interval(
+                lambda { |now|
+                  duration == 'quarter' ? now.prev_quarter : (now - 1.send(duration)).send("beginning_of_#{duration}")
+                },
+                ->(now) { now.send("beginning_of_#{duration}") }
+              )
+            end
+
+            def self.previous_interval_to_date(duration)
+              interval(
+                ->(now) { now.send("beginning_of_#{duration}") },
+                ->(now) { now }
+              )
+            end
+
+            def self.transforms
+              {
+                Operators::BEFORE => [compare(Operators::LESS_THAN) { |_now, value| Time.parse(value.to_s) }],
+                Operators::AFTER => [compare(Operators::GREATER_THAN) { |_now, value| Time.parse(value.to_s) }],
+                Operators::PAST => [compare(Operators::LESS_THAN) { |now| now }],
+                Operators::FUTURE => [compare(Operators::GREATER_THAN) { |now| now }],
+                Operators::BEFORE_X_HOURS_AGO => [compare(Operators::LESS_THAN) { |now, value| now - value.hours }],
+                Operators::AFTER_X_HOURS_AGO => [compare(Operators::GREATER_THAN) { |now, value| now - value.hours }],
+                Operators::PREVIOUS_WEEK_TO_DATE => [previous_interval_to_date('week')],
+                Operators::PREVIOUS_MONTH_TO_DATE => [previous_interval_to_date('month')],
+                Operators::PREVIOUS_QUARTER_TO_DATE => [previous_interval_to_date('quarter')],
+                Operators::PREVIOUS_YEAR_TO_DATE => [previous_interval_to_date('year')],
+                Operators::YESTERDAY => [previous_interval('day')],
+                Operators::PREVIOUS_WEEK => [previous_interval('week')],
+                Operators::PREVIOUS_MONTH => [previous_interval('month')],
+                Operators::PREVIOUS_QUARTER => [previous_interval('quarter')],
+                Operators::PREVIOUS_YEAR => [previous_interval('year')],
+                Operators::PREVIOUS_X_DAYS_TO_DATE => [
+                  interval(
+                    ->(now, value) { (now - value.days).beginning_of_day },
+                    ->(now, _value) { now }
+                  )
+                ],
+                Operators::PREVIOUS_X_DAYS => [
+                  interval(
+                    ->(now, value) { (now - value.days).beginning_of_day },
+                    ->(now, _value) { now.beginning_of_day }
+                  )
+                ],
+                Operators::TODAY => [
+                  interval(
+                    ->(now) { now.beginning_of_day },
+                    ->(now) { (now + 1.day).beginning_of_day }
+                  )
+                ]
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/query/filter.rb

@@ -0,0 +1,45 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class Filter
+        attr_reader :condition_tree, :segment, :sort, :search, :search_extended, :page
+
+        def initialize(condition_tree: nil, search: nil, search_extended: nil, segment: nil, sort: nil, page: nil)
+          @condition_tree = condition_tree
+          @search = search
+          @search_extended = search_extended
+          @segment = segment
+          @sort = sort
+          @page = page
+        end
+
+        def to_h
+          {
+            condition_tree: @condition_tree,
+            search: @search,
+            search_extended: @search_extended,
+            segment: @segment,
+            sort: @sort,
+            page: @page
+          }
+        end
+
+        def nestable?
+          !@search && !@segment
+        end
+
+        def override(args)
+          args = to_h.merge(args)
+
+          Filter.new(**args)
+        end
+
+        def nest(prefix)
+          raise ForestException, "Filter can't be nested" unless nestable?
+
+          override(condition_tree: @condition_tree&.nest(prefix))
+        end
+      end
+    end
+  end
+end