forest_admin_datasource_toolkit 1.0.0.pre.beta.22 → 1.0.0.pre.beta.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcd6677ce3f931b19f6b5e575c3235c724e8d23022ad43b768c11429cb59f537
-  data.tar.gz: 89acacaa778c611cc3bccda72f2757bd738bee2a446381bdc6c33e7e037135f7
+  metadata.gz: a6db15a9f9827fdef57eb3a018ec0c3a9851a5ab131f26b38d2792fc12cb897d
+  data.tar.gz: 83ed4a24c607297af411ec2bbeacf739bb2c9f5c6b611343885a7237abb1deb6
 SHA512:
-  metadata.gz: d8453ea97a82fd1c8b329a48c102cd355eaf34488103e60baa4682dce03a648f0a8aea55497ec3b3484acfc1b7ce66c20e9f06d7bcc12dd9f614c03742ff136c
-  data.tar.gz: 374f7e949ad419ab3fb9f2928031e0c9257f8a8d1258652b829c36acadeba5da8cc81e2e6d2e6f2430ffe221550999d2e2a67f8bff460adcd08ae43d826b0342
+  metadata.gz: 2169823cdaa62b57be4fbef2cbd5986c4576d43ea063425ab741a9abd58af0b83b17881cad854f1e2ec6a3fe8de1006e589842fa6cfe052394252748e4d4ad53
+  data.tar.gz: fbc3374aefaeda605d14e882e9a988142d9a5e43c3d147546bbd1cfa17c6978429f953367e9588c02d47684146c41a32f664887d4d30205cbc228698654f3d0b

data/lib/forest_admin_datasource_toolkit/collection.rb

@@ -1,6 +1,6 @@
 module ForestAdminDatasourceToolkit
   class Collection < Components::Contracts::CollectionContract
-    attr_accessor :fields, :segments
+    attr_accessor :segments
 
     attr_reader :actions,
                 :charts,
@@ -17,13 +17,17 @@ module ForestAdminDatasourceToolkit
       @datasource = datasource
       @name = name
       @native_driver = native_driver
-      @fields = {}
-      @schema = {}
-      @fields = {}
+      @schema = {
+        fields: {}
+      }
       @actions = {}
       @segments = {}
       @charts = {}
       @searchable = false
+      @countable = false
+    end
+
+    def enable_count
       @countable = true
     end
 
@@ -35,10 +39,14 @@ module ForestAdminDatasourceToolkit
       @searchable
     end
 
+    def fields
+      @schema[:fields]
+    end
+
     def add_field(name, field)
-      raise Exceptions::ForestException, "Field #{name} already defined in collection" if @fields.key?(name)
+      raise Exceptions::ForestException, "Field #{name} already defined in collection" if @schema[:fields].key?(name)
 
-      @fields[name] = field
+      @schema[:fields][name] = field
     end
 
     def add_fields(fields)

data/lib/forest_admin_datasource_toolkit/components/charts/chart.rb

@@ -0,0 +1,11 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Charts
+      class Chart
+        def serialize
+          raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/charts/leaderboard_chart.rb

@@ -0,0 +1,24 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Charts
+      class LeaderboardChart
+        include ForestAdminDatasourceToolkit::Validations
+
+        attr_reader :data
+
+        def initialize(data)
+          super()
+          @data = data
+        end
+
+        def serialize
+          data.each do |item|
+            ChartValidator.validate?(!item.key?(:key) || !item.key?(:value), item, "'key', 'value'")
+          end
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/charts/line_chart.rb

@@ -0,0 +1,24 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Charts
+      class LineChart
+        include ForestAdminDatasourceToolkit::Validations
+
+        attr_reader :data
+
+        def initialize(data)
+          super()
+          @data = data
+        end
+
+        def serialize
+          data.each do |item|
+            ChartValidator.validate?(!item.key?(:label) || !item.key?(:values), item, "'label', 'values'")
+          end
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/charts/objective_chart.rb

@@ -0,0 +1,22 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Charts
+      class ObjectiveChart
+        attr_reader :value, :objective
+
+        def initialize(value, objective = nil)
+          super()
+          @value = value
+          @objective = objective
+        end
+
+        def serialize
+          result = { value: value }
+          result[:objective] = objective if objective
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/charts/percentage_chart.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Charts
+      class PercentageChart
+        attr_reader :value
+
+        def initialize(value)
+          super()
+          @value = value
+        end
+
+        def serialize
+          value
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/charts/pie_chart.rb

@@ -0,0 +1,24 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Charts
+      class PieChart
+        include ForestAdminDatasourceToolkit::Validations
+
+        attr_reader :data
+
+        def initialize(data)
+          super()
+          @data = data
+        end
+
+        def serialize
+          data.each do |item|
+            ChartValidator.validate?(!item.key?(:key) || !item.key?(:value), item, "'key', 'value'")
+          end
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/charts/smart_chart.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Charts
+      class SmartChart
+        attr_reader :data
+
+        def initialize(data)
+          super()
+          @data = data
+        end
+
+        def serialize
+          data
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/charts/value_chart.rb

@@ -0,0 +1,19 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Charts
+      class ValueChart
+        attr_reader :value, :previous_value
+
+        def initialize(value, previous_value = nil)
+          super()
+          @value = value
+          @previous_value = previous_value
+        end
+
+        def serialize
+          { countCurrent: value, countPrevious: previous_value }
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/components/contracts/datasource_contract.rb

@@ -10,7 +10,7 @@ module ForestAdminDatasourceToolkit
           raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
         end
 
-        def collection(name)
+        def get_collection(name)
           raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
         end
 

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

@@ -1,3 +1,6 @@
+require 'active_support/all'
+require 'active_support/core_ext/numeric/time'
+
 module ForestAdminDatasourceToolkit
   module Components
     module Query
@@ -17,6 +20,171 @@ module ForestAdminDatasourceToolkit
 
           raise ForestException, "Aggregate operation #{operation} not allowed"
         end
+
+        def projection
+          aggregate_fields = []
+          aggregate_fields << field if field
+
+          groups.each do |group|
+            aggregate_fields << group[:field]
+          end
+
+          Projection.new(aggregate_fields)
+        end
+
+        def replace_fields(handler)
+          result = clone
+          result.field = handler.call(result.field) if result.field
+          result.groups = result.groups.map do |group|
+            {
+              field: handler.call(group[:field]),
+              operation: group[:operation] || nil
+            }
+          end
+          result
+        end
+
+        def override(**args)
+          Aggregation.new(**to_h.merge(args))
+        end
+
+        def apply(records, timezone, limit = nil)
+          rows = format_summaries(create_summaries(records, timezone))
+          rows.sort do |r1, r2|
+            if r1[:value] == r2[:value]
+              0
+            else
+              r1[:value] < r2[:value] ? 1 : -1
+            end
+          end
+
+          rows = rows[0..limit - 1] if limit && rows.size > limit
+
+          rows
+        end
+
+        def nest(prefix = nil)
+          return self unless prefix
+
+          nested_field = nil
+          nested_groups = []
+          nested_field = "#{prefix}:#{field}" if field
+
+          if groups.size.positive?
+            nested_groups = groups.map do |item|
+              {
+                field: "#{prefix}:#{item[:field]}",
+                operation: item[:operation]
+              }
+            end
+          end
+
+          self.class.new(operation: operation, field: nested_field, groups: nested_groups)
+        end
+
+        def to_h
+          {
+            operation: operation,
+            field: field,
+            groups: groups
+          }
+        end
+
+        private
+
+        def create_summaries(records, timezone)
+          grouping_map = {}
+
+          records.each do |record|
+            group = create_group(record, timezone)
+            unique_key = Digest::SHA1.hexdigest(group.to_json)
+            summary = grouping_map[unique_key] || create_summary(group)
+
+            update_summary_in_place(summary, record)
+
+            grouping_map[unique_key] = summary
+          end
+
+          grouping_map.values
+        end
+
+        def format_summaries(summaries)
+          if operation == 'Avg'
+            summaries
+              .select { |summary| (summary['Count']).positive? }
+              .map do |summary|
+              {
+                group: summary['group'],
+                value: summary['Sum'] / summary['Count']
+              }
+            end
+          else
+            summaries.map do |summary|
+              {
+                group: summary['group'],
+                value: operation == 'Count' && !field ? summary['starCount'] : summary[operation]
+              }
+            end
+          end
+        end
+
+        def create_group(record, timezone)
+          group = {}
+
+          groups.each do |value|
+            group_value = record[value[:field]]
+            group[value[:field]] = apply_date_operation(group_value, value[:operation], timezone)
+          end
+
+          group
+        end
+
+        def apply_date_operation(value, operation, timezone)
+          return value unless operation
+
+          case operation
+          when 'Year'
+            DateTime.parse(value).in_time_zone(timezone).strftime('%Y-01-01')
+          when 'Month'
+            DateTime.parse(value).in_time_zone(timezone).strftime('%Y-%m-01')
+          when 'Day'
+            DateTime.parse(value).in_time_zone(timezone).strftime('%Y-%m-%d')
+          when 'Week'
+            DateTime.parse(value).in_time_zone(timezone).beginning_of_month.strftime('%Y-%m-%d')
+          else
+            value
+          end
+        end
+
+        def create_summary(group)
+          {
+            'group' => group,
+            'starCount' => 0,
+            'Count' => 0,
+            'Sum' => 0,
+            'Min' => nil,
+            'Max' => nil
+          }
+        end
+
+        def update_summary_in_place(summary, record)
+          summary['starCount'] += 1
+
+          return unless field
+
+          value = ForestAdminDatasourceToolkit::Utils::Record.field_value(record, field)
+
+          if value
+            min = summary['Min']
+            max = summary['Max']
+
+            summary['Count'] += 1
+            summary['Min'] = value if min.nil? || value < min
+            summary['Max'] = value if max.nil? || value < max
+          end
+
+          summary['Sum'] += value if value.is_a?(Numeric)
+        end
       end
     end
   end

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

@@ -41,18 +41,18 @@ module ForestAdminDatasourceToolkit
                 depends_on = alt[:depends_on]
                 valid = alt[:for_types].nil? || alt[:for_types].include?(column_type)
 
-                if valid && !visited.include?(alt)
-                  depends_replacers = depends_on.map do |replacement|
-                    get_replacer(replacement, filter_operators, column_type, visited + [alt])
-                  end
+                next unless valid && !visited.include?(alt)
 
-                  if depends_replacers.all? { |r| !r.nil? }
-                    return lambda { |leaf, timezone|
-                      replacer.call(leaf).replace_leafs do |sub_leaf|
-                        depends_replacers[depends_on.index(sub_leaf.operator)].call(sub_leaf, timezone)
-                      end
-                    }
-                  end
+                depends_replacers = depends_on.map do |replacement|
+                  get_replacer(replacement, filter_operators, column_type, visited + [alt])
+                end
+
+                if depends_replacers.all? { |r| !r.nil? }
+                  return lambda { |leaf, timezone|
+                    replacer.call(leaf).replace_leafs do |sub_leaf|
+                      depends_replacers[depends_on.index(sub_leaf.operator)].call(sub_leaf, timezone)
+                    end
+                  }
                 end
               end
 

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

@@ -22,7 +22,7 @@ module ForestAdminDatasourceToolkit
             raise ForestException, 'Collection must have at least one primary key' if primary_key_names.empty?
 
             primary_key_names.each do |name|
-              operators = collection.fields[name].filter_operators
+              operators = collection.schema[:fields][name].filter_operators
               unless operators.include?(Operators::EQUAL) || operators.include?(Operators::IN)
                 raise ForestException, "Field '#{name}' must support operators: ['Equal', 'In']"
               end

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

@@ -54,15 +54,15 @@ module ForestAdminDatasourceToolkit
             def self.previous_interval(duration)
               interval(
                 lambda { |now|
-                  duration == 'quarter' ? now.prev_quarter : (now - 1.send(duration)).send("beginning_of_#{duration}")
+                  duration == 'quarter' ? now.prev_quarter : (now - 1.send(duration)).send(:"beginning_of_#{duration}")
                 },
-                ->(now) { now.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.send(:"beginning_of_#{duration}") },
                 ->(now) { now }
               )
             end

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

@@ -61,7 +61,7 @@ module ForestAdminDatasourceToolkit
           if relation.is_a?(OneToManySchema)
             origin_tree = Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value)
           else
-            through_collection = collection.datasource.collection(relation.through_collection)
+            through_collection = collection.datasource.get_collection(relation.through_collection)
             through_tree = ConditionTreeFactory.intersect([
                                                             Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value),
                                                             Nodes::ConditionTreeLeaf.new(relation.foreign_key, Operators::PRESENT)
@@ -86,8 +86,8 @@ module ForestAdminDatasourceToolkit
           unit = unit.downcase
           start = "beginning_of_#{unit}"
           end_ = "end_of_#{unit}"
-          start_period = Time.now.in_time_zone(timezone).send("prev_#{unit}").send(start)
-          end_period = Time.now.in_time_zone(timezone).send("prev_#{unit}").send(end_)
+          start_period = Time.now.in_time_zone(timezone).send(:"prev_#{unit}").send(start)
+          end_period = Time.now.in_time_zone(timezone).send(:"prev_#{unit}").send(end_)
 
           get_previous_condition_tree(field, start_period.to_datetime, end_period.to_datetime)
         end
@@ -104,13 +104,13 @@ module ForestAdminDatasourceToolkit
         end
 
         def self.make_through_filter(collection, id, relation_name, caller, base_foreign_filter)
-          relation = collection.fields[relation_name]
+          relation = collection.schema[:fields][relation_name]
           origin_value = Utils::Collection.get_value(collection, caller, id, relation.origin_key_target)
           foreign_relation = Utils::Collection.get_through_target(collection, relation_name)
 
           # Optimization for many to many when there is not search/segment (saves one query)
           if foreign_relation && base_foreign_filter.nestable?
-            foreign_key = collection.datasource.collection(relation.through_collection).fields[relation.foreign_key]
+            foreign_key = collection.datasource.get_collection(relation.through_collection).schema[:fields][relation.foreign_key]
             base_through_filter = base_foreign_filter.nest(foreign_relation)
             condition_tree = ConditionTreeFactory.intersect(
               [
@@ -129,7 +129,7 @@ module ForestAdminDatasourceToolkit
 
           # Otherwise we have no choice but to call the target collection so that search and segment
           # are correctly apply, and then match ids in the though collection.
-          target = collection.datasource.collection(relation.foreign_collection)
+          target = collection.datasource.get_collection(relation.foreign_collection)
           records = target.list(
             caller,
             make_foreign_filter(collection, id, relation_name, caller, base_foreign_filter),

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

@@ -9,8 +9,8 @@ module ForestAdminDatasourceToolkit
           end
 
           relations.each do |relation, projection|
-            schema = collection.fields[relation]
-            association = collection.datasource.collection(schema.foreign_collection)
+            schema = collection.schema[:fields][relation]
+            association = collection.datasource.get_collection(schema.foreign_collection)
             projection_with_pks = projection.with_pks(association).nest(prefix: relation)
 
             projection_with_pks.each { |field| push(field) unless include?(field) }

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

@@ -4,14 +4,14 @@ module ForestAdminDatasourceToolkit
       class ProjectionFactory
         include ForestAdminDatasourceToolkit::Utils
         def self.all(collection)
-          projection_fields = collection.fields.reduce([]) do |memo, path|
+          projection_fields = collection.schema[:fields].reduce([]) do |memo, path|
             column_name = path[0]
             schema = path[1]
             memo += [column_name] if schema.type == 'Column'
 
             if schema.type == 'OneToOne' || schema.type == 'ManyToOne'
-              relation = collection.datasource.collection(schema.foreign_collection)
-              relation_columns = relation.fields
+              relation = collection.datasource.get_collection(schema.foreign_collection)
+              relation_columns = relation.schema[:fields]
                                          .select { |_column_name, relation_column| relation_column.type == 'Column' }
                                          .keys
                                          .map { |relation_column_name| "#{column_name}:#{relation_column_name}" }

data/lib/forest_admin_datasource_toolkit/datasource.rb

@@ -8,7 +8,7 @@ module ForestAdminDatasourceToolkit
       @collections = {}
     end
 
-    def collection(name)
+    def get_collection(name)
       raise Exceptions::ForestException, "Collection #{name} not found." unless @collections.key? name
 
       @collections[name]

data/lib/forest_admin_datasource_toolkit/decorators/collection_decorator.rb

@@ -0,0 +1,110 @@
+module ForestAdminDatasourceToolkit
+  module Decorators
+    class CollectionDecorator < Collection
+      attr_reader :datasource, :child_collection, :last_schema
+
+      def initialize(child_collection, datasource)
+        super
+        @child_collection = child_collection
+        @datasource = datasource
+
+        # When the child collection invalidates its schema, we also invalidate ours.
+        # This is done like this, and not in the markSchemaAsDirty method, because we don't have
+        # 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 {
+          # 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
+
+      def native_driver
+        # TODO
+      end
+
+      def schema
+        unless @last_schema
+          sub_schema = @child_collection.schema
+          @last_schema = refine_schema(sub_schema)
+        end
+
+        @last_schema
+      end
+
+      def name
+        @child_collection.name
+      end
+
+      def execute(caller, name, data, filter = nil)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.execute(caller, name, data, refined_filter)
+      end
+
+      def get_form(caller, name, data = nil, filter = nil, metas = nil)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.get_form(caller, name, data, refined_filter, metas)
+      end
+
+      def create(caller, data)
+        @child_collection.create(caller, data)
+      end
+
+      def list(caller, filter = nil, projection = nil)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.list(caller, refined_filter, projection)
+      end
+
+      def update(caller, filter, patch)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.update(caller, refined_filter, patch)
+      end
+
+      def delete(caller, filter)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.delete(caller, refined_filter)
+      end
+
+      def aggregate(caller, filter, aggregation, limit = nil)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.aggregate(caller, refined_filter, aggregation, limit)
+      end
+
+      def render_chart(caller, name, record_id)
+        @child_collection.render_chart(caller, name, record_id)
+      end
+
+      protected
+
+      def mark_schema_as_dirty
+        @last_schema = nil
+      end
+
+      def refine_filter(_caller, filter = nil)
+        filter
+      end
+
+      def refine_schema(sub_schema)
+        sub_schema
+      end
+
+      private
+
+      def push_customization(customization)
+        @stack.queue_customization(customization)
+
+        self
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/decorators/datasource_decorator.rb

@@ -0,0 +1,28 @@
+module ForestAdminDatasourceToolkit
+  module Decorators
+    class DatasourceDecorator
+      def initialize(child_datasource, collection_decorator_class)
+        @child_datasource = child_datasource
+        @collection_decorator_class = collection_decorator_class
+        @decorators = {}
+      end
+
+      def collections
+        @child_datasource.collections.transform_values { |c| get_collection(c.name) }
+      end
+
+      def get_collection(name)
+        collection = @child_datasource.get_collection(name)
+        unless @decorators.key?(collection.name)
+          @decorators[collection.name] = @collection_decorator_class.new(collection, self)
+        end
+
+        @decorators[collection.name]
+      end
+
+      def render_chart(caller, name)
+        @child_datasource.render_chart(caller, name)
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/utils/collection.rb

@@ -7,10 +7,10 @@ module ForestAdminDatasourceToolkit
       include ForestAdminDatasourceToolkit::Exceptions
 
       def self.get_inverse_relation(collection, relation_name)
-        relation_field = collection.fields[relation_name]
-        foreign_collection = collection.datasource.collection(relation_field.foreign_collection)
+        relation_field = collection.schema[:fields][relation_name]
+        foreign_collection = collection.datasource.get_collection(relation_field.foreign_collection)
 
-        inverse = foreign_collection.fields.select do |_name, field|
+        inverse = foreign_collection.schema[:fields].select do |_name, field|
           field.is_a?(RelationSchema) &&
             field.foreign_collection == collection.name &&
             (
@@ -50,7 +50,7 @@ module ForestAdminDatasourceToolkit
       end
 
       def self.get_field_schema(collection, field_name)
-        fields = collection.fields
+        fields = collection.schema[:fields]
         unless field_name.include?(':')
           raise ForestException, "Column not found #{collection.name}.#{field_name}" unless fields.key?(field_name)
 
@@ -67,7 +67,7 @@ module ForestAdminDatasourceToolkit
         end
 
         get_field_schema(
-          collection.datasource.collection(relation_schema.foreign_collection), field_name.split(':')[1..].join(':')
+          collection.datasource.get_collection(relation_schema.foreign_collection), field_name.split(':')[1..].join(':')
         )
       end
 
@@ -90,11 +90,11 @@ module ForestAdminDatasourceToolkit
       end
 
       def self.get_through_target(collection, relation_name)
-        relation = collection.fields[relation_name]
+        relation = collection.schema[:fields][relation_name]
         raise ForestException, 'Relation must be many to many' unless relation.is_a?(ManyToManySchema)
 
-        through_collection = collection.datasource.collection(relation.through_collection)
-        through_collection.fields.select do |field_name, field|
+        through_collection = collection.datasource.get_collection(relation.through_collection)
+        through_collection.schema[:fields].select do |field_name, field|
           if field.is_a?(ManyToOneSchema) &&
              field.foreign_collection == relation.foreign_collection &&
              field.foreign_key == relation.foreign_key &&
@@ -106,15 +106,32 @@ module ForestAdminDatasourceToolkit
         nil
       end
 
+      def self.get_through_origin(collection, relation_name)
+        relation = collection.schema[:fields][relation_name]
+        raise ForestException, 'Relation must be many to many' unless relation.is_a?(ManyToManySchema)
+
+        through_collection = collection.datasource.get_collection(relation.through_collection)
+        through_collection.schema[:fields].select do |field_name, field|
+          if field.is_a?(ManyToOneSchema) &&
+             field.foreign_collection == collection.name &&
+             field.foreign_key == relation.origin_key &&
+             field.foreign_key_target == relation.origin_key_target
+            return field_name
+          end
+        end
+
+        nil
+      end
+
       def self.list_relation(collection, id, relation_name, caller, foreign_filter, projection)
-        relation = collection.fields[relation_name]
-        foreign_collection = collection.datasource.collection(relation.foreign_collection)
+        relation = collection.schema[:fields][relation_name]
+        foreign_collection = collection.datasource.get_collection(relation.foreign_collection)
 
         if relation.is_a?(ManyToManySchema) && foreign_filter.nestable?
           foreign_relation = get_through_target(collection, relation_name)
 
           if foreign_relation
-            through_collection = collection.datasource.collection(relation.through_collection)
+            through_collection = collection.datasource.get_collection(relation.through_collection)
             records = through_collection.list(
               caller,
               FilterFactory.make_through_filter(collection, id, relation_name, caller, foreign_filter),
@@ -133,13 +150,13 @@ module ForestAdminDatasourceToolkit
       end
 
       def self.aggregate_relation(collection, id, relation_name, caller, foreign_filter, aggregation, limit = nil)
-        relation = collection.fields[relation_name]
-        foreign_collection = collection.datasource.collection(relation.foreign_collection)
+        relation = collection.schema[:fields][relation_name]
+        foreign_collection = collection.datasource.get_collection(relation.foreign_collection)
 
         if relation.is_a?(ManyToManySchema) && foreign_filter.nestable?
           foreign_relation = get_through_target(collection, relation_name)
           if foreign_relation
-            through_collection = collection.datasource.collection(relation.through_collection)
+            through_collection = collection.datasource.get_collection(relation.through_collection)
 
             return through_collection.aggregate(
               caller,

data/lib/forest_admin_datasource_toolkit/utils/schema.rb

@@ -2,33 +2,33 @@ module ForestAdminDatasourceToolkit
   module Utils
     class Schema
       def self.foreign_key?(collection, name)
-        field = collection.fields[name]
+        field = collection.schema[:fields][name]
 
         field.type == 'Column' &&
-          collection.fields.any? do |_key, relation|
+          collection.schema[:fields].any? do |_key, relation|
             relation.type == 'ManyToOne' && relation.foreign_key == name
           end
       end
 
       def self.primary_key?(collection, name)
-        field = collection.fields[name]
+        field = collection.schema[:fields][name]
 
         field.type == 'Column' && field.is_primary_key
       end
 
       def self.primary_keys(collection)
-        collection.fields.keys.select do |field_name|
-          field = collection.fields[field_name]
+        collection.schema[:fields].keys.select do |field_name|
+          field = collection.schema[:fields][field_name]
           field.type == 'Column' && field.is_primary_key
         end
       end
 
       def self.get_to_many_relation(collection, relation_name)
-        unless collection.fields.key?(relation_name)
+        unless collection.schema[:fields].key?(relation_name)
           raise Exceptions::ForestException, "Relation #{relation_name} not found"
         end
 
-        relation = collection.fields[relation_name]
+        relation = collection.schema[:fields][relation_name]
 
         if relation.type != 'OneToMany' && relation.type != 'ManyToMany'
           raise Exceptions::ForestException,

data/lib/forest_admin_datasource_toolkit/validations/chart_validator.rb

@@ -0,0 +1,15 @@
+module ForestAdminDatasourceToolkit
+  module Validations
+    class ChartValidator
+      def self.validate?(condition, result, key_names)
+        if condition
+          result_keys = result.keys.join(',')
+          raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                "The result columns must be named '#{key_names}' instead of '#{result_keys}'"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceToolkit
-  VERSION = "1.0.0-beta.22"
+  VERSION = "1.0.0-beta.24"
 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.22
+  version: 1.0.0.pre.beta.24
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-08 00:00:00.000000000 Z
+date: 2023-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -56,6 +56,14 @@ files:
 - lib/forest_admin_datasource_toolkit.rb
 - lib/forest_admin_datasource_toolkit/collection.rb
 - lib/forest_admin_datasource_toolkit/components/caller.rb
+- lib/forest_admin_datasource_toolkit/components/charts/chart.rb
+- lib/forest_admin_datasource_toolkit/components/charts/leaderboard_chart.rb
+- lib/forest_admin_datasource_toolkit/components/charts/line_chart.rb
+- lib/forest_admin_datasource_toolkit/components/charts/objective_chart.rb
+- lib/forest_admin_datasource_toolkit/components/charts/percentage_chart.rb
+- lib/forest_admin_datasource_toolkit/components/charts/pie_chart.rb
+- lib/forest_admin_datasource_toolkit/components/charts/smart_chart.rb
+- lib/forest_admin_datasource_toolkit/components/charts/value_chart.rb
 - lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb
 - lib/forest_admin_datasource_toolkit/components/contracts/datasource_contract.rb
 - lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
@@ -74,6 +82,8 @@ files:
 - lib/forest_admin_datasource_toolkit/components/query/projection.rb
 - lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb
 - 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/exceptions/forest_exception.rb
 - lib/forest_admin_datasource_toolkit/schema/column_schema.rb
 - lib/forest_admin_datasource_toolkit/schema/primitive_type.rb
@@ -85,6 +95,7 @@ files:
 - lib/forest_admin_datasource_toolkit/utils/collection.rb
 - lib/forest_admin_datasource_toolkit/utils/record.rb
 - lib/forest_admin_datasource_toolkit/utils/schema.rb
+- lib/forest_admin_datasource_toolkit/validations/chart_validator.rb
 - lib/forest_admin_datasource_toolkit/version.rb
 - sig/forest_admin_datasource_toolkit.rbs
 - sig/forest_admin_datasource_toolkit/collection.rbs