forest_admin_datasource_toolkit 1.0.0.pre.beta.24 → 1.0.0.pre.beta.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6db15a9f9827fdef57eb3a018ec0c3a9851a5ab131f26b38d2792fc12cb897d
-  data.tar.gz: 83ed4a24c607297af411ec2bbeacf739bb2c9f5c6b611343885a7237abb1deb6
+  metadata.gz: 9749205ecd01ce84b131e59b25235bd4555bd5bb64ec5620d283bc46ab51ebb3
+  data.tar.gz: 474671b8aa198bd1a2cbb1b0c95e95bab9e2275572344990376aa37d1b3773ef
 SHA512:
-  metadata.gz: 2169823cdaa62b57be4fbef2cbd5986c4576d43ea063425ab741a9abd58af0b83b17881cad854f1e2ec6a3fe8de1006e589842fa6cfe052394252748e4d4ad53
-  data.tar.gz: fbc3374aefaeda605d14e882e9a988142d9a5e43c3d147546bbd1cfa17c6978429f953367e9588c02d47684146c41a32f664887d4d30205cbc228698654f3d0b
+  metadata.gz: f7d84033214299dbcec6ce24d8d20a538de1895dca6349ef5b32c9cbf3744df3df3994a5cb10263055a4f8ac30c160756595a80c6b1088e100f25d389e3b4732
+  data.tar.gz: da6e1e8ead04fab78151c72117a73d89c0b4665df2c1c10c16b130fe9e492ab0ca5ec7b9b552343b8e5b90a99dbd5469a4da761d4d90ac24a753f42399e3ba2f

data/lib/forest_admin_datasource_toolkit/collection.rb

@@ -18,7 +18,8 @@ module ForestAdminDatasourceToolkit
       @name = name
       @native_driver = native_driver
       @schema = {
-        fields: {}
+        fields: {},
+        countable: false
       }
       @actions = {}
       @segments = {}
@@ -28,11 +29,11 @@ module ForestAdminDatasourceToolkit
     end
 
     def enable_count
-      @countable = true
+      @schema[:countable] = true
     end
 
     def is_countable?
-      @countable
+      @schema[:countable]
     end
 
     def is_searchable?

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

@@ -49,7 +49,7 @@ module ForestAdminDatasourceToolkit
 
                 if depends_replacers.all? { |r| !r.nil? }
                   return lambda { |leaf, timezone|
-                    replacer.call(leaf).replace_leafs do |sub_leaf|
+                    replacer.call(leaf, timezone).replace_leafs do |sub_leaf|
                       depends_replacers[depends_on.index(sub_leaf.operator)].call(sub_leaf, timezone)
                     end
                   }

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

@@ -1,3 +1,6 @@
+require 'active_support'
+require 'active_support/core_ext/string'
+
 module ForestAdminDatasourceToolkit
   module Components
     module Query
@@ -11,7 +14,7 @@ module ForestAdminDatasourceToolkit
 
             def initialize(field, operator, value = nil)
               @field = field
-              @operator = operator
+              @operator = operator.underscore
               @value = value
               valid_operator(@operator) if @operator
               super()
@@ -32,14 +35,14 @@ module ForestAdminDatasourceToolkit
             end
 
             def inverse
-              return override(operator: "Not_#{@operator}") if Operators.exist?("Not_#{@operator}")
-              return override(operator: @operator[4..]) if @operator.start_with?('Not')
+              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')
+              when Operators::BLANK
+                override(operator: Operators::BLANK)
+              when Operators::PRESENT
+                override(operator: Operators::PRESENT)
               else
                 raise ForestException, "Operator: #{@operator} cannot be inverted."
               end

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

@@ -3,64 +3,53 @@ module ForestAdminDatasourceToolkit
     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
+          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 = 'i_like'.freeze
+          NOT_CONTAINS = 'not_contains'.freeze
+          CONTAINS = 'contains'.freeze
+          I_CONTAINS = 'i_contains'.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 = 'i_starts_with'.freeze
+          ENDS_WITH = 'ends_with'.freeze
+          I_ENDS_WITH = 'i_ends_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
+            constants.map { |constant| const_get(constant) }
           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)
+            all.include?(operator_value)
           end
 
           def self.interval_operators

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

@@ -12,41 +12,41 @@ module ForestAdminDatasourceToolkit
                   {
                     depends_on: [Operators::IN],
                     for_types: ['String'],
-                    replacer: ->(leaf) { leaf.override({ operator: Operators::IN, value: [nil, ''] }) }
+                    replacer: proc { |leaf| leaf.override({ operator: Operators::IN, value: [nil, ''] }) }
                   },
                   {
                     depends_on: [Operators::MISSING],
-                    replacer: ->(leaf) { leaf.override({ operator: Operators::MISSING }) }
+                    replacer: proc { |leaf| leaf.override({ operator: Operators::MISSING }) }
                   }
                 ],
                 Operators::MISSING => [
                   {
                     depends_on: [Operators::EQUAL],
-                    replacer: ->(leaf) { leaf.override({ operator: Operators::EQUAL, value: nil }) }
+                    replacer: proc { |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, ''] }) }
+                    replacer: proc { |leaf| leaf.override({ operator: Operators::NOT_IN, value: [nil, ''] }) }
                   },
                   {
                     depends_on: [Operators::NOT_EQUAL],
-                    replacer: ->(leaf) { leaf.override({ operator: Operators::NOT_EQUAL, value: nil }) }
+                    replacer: proc { |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] }) }
+                    replacer: proc { |leaf| leaf.override({ operator: Operators::IN, value: [leaf.value] }) }
                   }
                 ],
                 Operators::IN => [
                   {
                     depends_on: [Operators::EQUAL, Operators::MATCH],
                     for_types: ['String'],
-                    replacer: lambda { |leaf|
+                    replacer: proc { |leaf|
                       values = leaf.value
                       conditions = []
 
@@ -68,7 +68,7 @@ module ForestAdminDatasourceToolkit
                   },
                   {
                     depends_on: [Operators::EQUAL],
-                    replacer: lambda { |leaf|
+                    replacer: proc { |leaf|
                       ConditionTreeFactory.union(
                         leaf.value.map { |item| leaf.override({ operator: Operators::EQUAL, value: item }) }
                       )
@@ -78,14 +78,14 @@ module ForestAdminDatasourceToolkit
                 Operators::NOT_EQUAL => [
                   {
                     depends_on: [Operators::NOT_IN],
-                    replacer: ->(leaf) { leaf.override({ operator: Operators::NOT_IN, value: [leaf.value] }) }
+                    replacer: proc { |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|
+                    replacer: proc { |leaf|
                       values = leaf.value
                       conditions = []
 
@@ -106,7 +106,7 @@ module ForestAdminDatasourceToolkit
                   },
                   {
                     depends_on: [Operators::NOT_EQUAL],
-                    replacer: lambda { |leaf|
+                    replacer: proc { |leaf|
                       ConditionTreeFactory.intersect(
                         leaf.value.map { |item| leaf.override({ operator: Operators::NOT_EQUAL, value: item }) }
                       )

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

@@ -8,17 +8,17 @@ module ForestAdminDatasourceToolkit
               operator = case_sensitive ? Operators::LIKE : Operators::I_LIKE
 
               {
-                dependsOn: [operator],
-                forTypes: ['String'],
-                replacer: ->(leaf) { leaf.override(operator: operator, value: get_pattern.call(leaf.value)) }
+                depends_on: [operator],
+                for_types: ['String'],
+                replacer: proc { |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|
+                depends_on: [Operators::MATCH],
+                for_types: ['String'],
+                replacer: proc { |leaf|
                   regex = leaf.value.gsub(/([\.\\\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:\-])/, '\\\\\1')
                   regex.gsub!('%', '.*')
                   regex.tr!('_', '.')
@@ -30,12 +30,12 @@ module ForestAdminDatasourceToolkit
 
             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::CONTAINS => [likes(proc { |value| "%#{value}%" }, true)],
+                Operators::STARTS_WITH => [likes(proc { |value| "#{value}%" }, true)],
+                Operators::ENDS_WITH => [likes(proc { |value| "%#{value}" }, true)],
+                Operators::I_CONTAINS => [likes(proc { |value| "%#{value}%" }, false)],
+                Operators::I_STARTS_WITH => [likes(proc { |value| "#{value}%" }, false)],
+                Operators::I_ENDS_WITH => [likes(proc { |value| "%#{value}" }, false)],
                 Operators::I_LIKE => [match(false)],
                 Operators::LIKE => [match(true)]
               }

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

@@ -13,9 +13,9 @@ module ForestAdminDatasourceToolkit
 
             def self.compare(operator)
               {
-                dependsOn: [operator],
-                forTypes: ['Date', 'Dateonly'],
-                replacer: lambda { |leaf, tz|
+                depends_on: [operator],
+                for_types: ['Date', 'Dateonly'],
+                replacer: proc { |leaf, tz|
                   leaf.override(operator: operator, value: format(yield(Time.now.in_time_zone(tz), leaf.value)))
                 }
               }
@@ -23,9 +23,9 @@ module ForestAdminDatasourceToolkit
 
             def self.interval(start_fn, end_fn)
               {
-                dependsOn: [Operators::LESS_THAN, Operators::GREATER_THAN],
-                forTypes: ['Date', 'Dateonly'],
-                replacer: lambda do |leaf, tz|
+                depends_on: [Operators::LESS_THAN, Operators::GREATER_THAN],
+                for_types: ['Date', 'Dateonly'],
+                replacer: proc do |leaf, tz|
                   value_greater_than = if leaf.value.nil?
                                          format(start_fn.call(Time.now.in_time_zone(tz)))
                                        else
@@ -53,17 +53,21 @@ module ForestAdminDatasourceToolkit
 
             def self.previous_interval(duration)
               interval(
-                lambda { |now|
-                  duration == 'quarter' ? now.prev_quarter : (now - 1.send(duration)).send(:"beginning_of_#{duration}")
+                proc { |now|
+                  if duration == 'quarter'
+                    now.prev_quarter.send(:"beginning_of_#{duration}")
+                  else
+                    (now - 1.send(duration)).send(:"beginning_of_#{duration}")
+                  end
                 },
-                ->(now) { now.send(:"beginning_of_#{duration}") }
+                proc { |now| now.send(:"beginning_of_#{duration}") }
               )
             end
 
             def self.previous_interval_to_date(duration)
               interval(
-                ->(now) { now.send(:"beginning_of_#{duration}") },
-                ->(now) { now }
+                proc { |now| now.send(:"beginning_of_#{duration}") },
+                proc { |now| now }
               )
             end
 
@@ -86,20 +90,20 @@ module ForestAdminDatasourceToolkit
                 Operators::PREVIOUS_YEAR => [previous_interval('year')],
                 Operators::PREVIOUS_X_DAYS_TO_DATE => [
                   interval(
-                    ->(now, value) { (now - value.days).beginning_of_day },
-                    ->(now, _value) { now }
+                    proc { |now, value| (now - value.days).beginning_of_day },
+                    proc { |now, _value| now }
                   )
                 ],
                 Operators::PREVIOUS_X_DAYS => [
                   interval(
-                    ->(now, value) { (now - value.days).beginning_of_day },
-                    ->(now, _value) { now.beginning_of_day }
+                    proc { |now, value| (now - value.days).beginning_of_day },
+                    proc { |now, _value| now.beginning_of_day }
                   )
                 ],
                 Operators::TODAY => [
                   interval(
-                    ->(now) { now.beginning_of_day },
-                    ->(now) { (now + 1.day).beginning_of_day }
+                    proc { |now| now.beginning_of_day },
+                    proc { |now| (now + 1.day).beginning_of_day }
                   )
                 ]
               }

data/lib/forest_admin_datasource_toolkit/decorators/collection_decorator.rb

@@ -13,14 +13,13 @@ module ForestAdminDatasourceToolkit
         # a reference to parent collections from children.
         return unless child_collection.is_a?(CollectionDecorator)
 
-        original_child_mark_schema_as_dirty = child_collection.mark_schema_as_dirty
-        child_collection.mark_schema_as_dirty = lambda {
+        child_collection.define_singleton_method(:mark_schema_as_dirty) do
           # Call the original method (the child)
           original_child_mark_schema_as_dirty.call(child_collection)
 
           # Invalidate our schema (the parent)
           mark_schema_as_dirty
-        }
+        end
       end
 
       def native_driver

data/lib/forest_admin_datasource_toolkit/decorators/schema/schema_collection_decorator.rb

@@ -0,0 +1,21 @@
+module ForestAdminDatasourceToolkit
+  module Decorators
+    module Schema
+      class SchemaCollectionDecorator < CollectionDecorator
+        def initialize(child_collection, datasource)
+          super
+          @schema_override = {}
+        end
+
+        def override_schema(value)
+          @schema_override.merge!(value)
+          mark_schema_as_dirty
+        end
+
+        def refine_schema(sub_schema)
+          sub_schema.merge(@schema_override)
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceToolkit
-  VERSION = "1.0.0-beta.24"
+  VERSION = "1.0.0-beta.26"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_toolkit
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.24
+  version: 1.0.0.pre.beta.26
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-18 00:00:00.000000000 Z
+date: 2024-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -84,6 +84,7 @@ files:
 - lib/forest_admin_datasource_toolkit/datasource.rb
 - lib/forest_admin_datasource_toolkit/decorators/collection_decorator.rb
 - lib/forest_admin_datasource_toolkit/decorators/datasource_decorator.rb
+- lib/forest_admin_datasource_toolkit/decorators/schema/schema_collection_decorator.rb
 - lib/forest_admin_datasource_toolkit/exceptions/forest_exception.rb
 - lib/forest_admin_datasource_toolkit/schema/column_schema.rb
 - lib/forest_admin_datasource_toolkit/schema/primitive_type.rb