forest_admin_datasource_toolkit 1.0.0.pre.beta.21

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

@@ -0,0 +1,158 @@
+require 'active_support/all'
+require 'active_support/core_ext/numeric/time'
+
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class FilterFactory
+        include ForestAdminDatasourceToolkit::Schema
+        include ForestAdminDatasourceToolkit::Schema::Relations
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        def self.get_previous_period_filter(filter, timezone)
+          filter.override(condition_tree: filter.condition_tree.replace_leafs do |leaf|
+                                            case leaf.operator
+                                            when Operators::YESTERDAY
+                                              get_previous_period_by_unit(leaf.field, 'Day', timezone)
+                                            when Operators::PREVIOUS_WEEK
+                                              get_previous_period_by_unit(leaf.field, 'Week', timezone)
+                                            when Operators::PREVIOUS_MONTH
+                                              get_previous_period_by_unit(leaf.field, 'Month', timezone)
+                                            when Operators::PREVIOUS_QUARTER
+                                              get_previous_period_by_unit(leaf.field, 'Quarter', timezone)
+                                            when Operators::PREVIOUS_YEAR
+                                              get_previous_period_by_unit(leaf.field, 'Year', timezone)
+                                            when Operators::PREVIOUS_WEEK_TO_DATE
+                                              leaf.override(operator: Operators::PREVIOUS_WEEK)
+                                            when Operators::PREVIOUS_MONTH_TO_DATE
+                                              leaf.override(operator: Operators::PREVIOUS_MONTH)
+                                            when Operators::PREVIOUS_QUARTER_TO_DATE
+                                              leaf.override(operator: Operators::PREVIOUS_QUARTER)
+                                            when Operators::PREVIOUS_YEAR_TO_DATE
+                                              leaf.override(operator: Operators::PREVIOUS_YEAR)
+                                            when Operators::TODAY
+                                              leaf.override(operator: Operators::YESTERDAY)
+                                            when Operators::PREVIOUS_X_DAYS
+                                              get_previous_x_days_period(leaf, timezone, 'Previous_X_Days')
+                                            when Operators::PREVIOUS_X_DAYS_TO_DATE
+                                              get_previous_x_days_period(leaf, timezone, 'Previous_X_Days_To_Date')
+                                            else
+                                              leaf
+                                            end
+                                          end)
+        end
+
+        def self.get_previous_condition_tree(field, start_period, end_period)
+          ConditionTreeFactory.intersect([
+                                           Nodes::ConditionTreeLeaf.new(field, Operators::GREATER_THAN,
+                                                                        start_period.strftime('%Y-%m-%d %H:%M:%S')),
+                                           Nodes::ConditionTreeLeaf.new(field, Operators::LESS_THAN,
+                                                                        end_period.strftime('%Y-%m-%d %H:%M:%S'))
+                                         ])
+        end
+
+        # Given a collection and a OneToMany/ManyToMany relation, generate a filter which
+        # - match only children of the provided recordId
+        # - can apply on the target collection of the relation
+        def self.make_foreign_filter(collection, id, relation_name, caller, base_foreign_filter)
+          relation = ForestAdminDatasourceToolkit::Utils::Schema.get_to_many_relation(collection, relation_name)
+          origin_value = ForestAdminDatasourceToolkit::Utils::Collection.get_value(collection, caller, id,
+                                                                                   relation.origin_key_target)
+          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_tree = ConditionTreeFactory.intersect([
+                                                            Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value),
+                                                            Nodes::ConditionTreeLeaf.new(relation.foreign_key, Operators::PRESENT)
+                                                          ])
+            records = through_collection.list(
+              caller,
+              Filter.new(condition_tree: through_tree),
+              Projection.new([relation.foreign_key])
+            )
+
+            origin_tree = Nodes::ConditionTreeLeaf.new(
+              relation.foreign_key_target,
+              Operators::IN,
+              records.map { |record| record[relation.foreign_key] }
+            )
+          end
+
+          base_foreign_filter.override(condition_tree: ConditionTreeFactory.intersect([base_foreign_filter.condition_tree, origin_tree]))
+        end
+
+        def self.get_previous_period_by_unit(field, unit, timezone)
+          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_)
+
+          get_previous_condition_tree(field, start_period.to_datetime, end_period.to_datetime)
+        end
+
+        def self.get_previous_x_days_period(leaf, timezone, operator)
+          start_period = Time.now.in_time_zone(timezone).send(:-, 2 * leaf.value.day).beginning_of_day
+          end_period = if operator == Operators::PREVIOUS_X_DAYS
+                         Time.now.in_time_zone(timezone).send(:-, leaf.value.day).beginning_of_day
+                       else
+                         Time.now.in_time_zone(timezone).send(:-, leaf.value.day)
+                       end
+
+          get_previous_condition_tree(leaf.field, start_period.to_datetime, end_period.to_datetime)
+        end
+
+        def self.make_through_filter(collection, id, relation_name, caller, base_foreign_filter)
+          relation = collection.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]
+            base_through_filter = base_foreign_filter.nest(foreign_relation)
+            condition_tree = ConditionTreeFactory.intersect(
+              [
+                Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value),
+                base_through_filter.condition_tree
+              ]
+            )
+
+            if foreign_key.type == 'Column' && foreign_key.filter_operators.include?(Operators::PRESENT)
+              present = Nodes::ConditionTreeLeaf.new(relation.foreign_key, Operators::PRESENT)
+              condition_tree = ConditionTreeFactory.intersect([condition_tree, present])
+            end
+
+            return base_through_filter.override(condition_tree: condition_tree)
+          end
+
+          # 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)
+          records = target.list(
+            caller,
+            make_foreign_filter(collection, id, relation_name, caller, base_foreign_filter),
+            Projection.new([relation.foreign_key_target])
+          )
+
+          Filter.new(
+            condition_tree: ConditionTreeFactory.intersect(
+              [
+                # only children of parent
+                Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value),
+
+                # only the children which match the conditions in baseForeignFilter
+                Nodes::ConditionTreeLeaf.new(
+                  relation.foreign_key,
+                  Operators::IN,
+                  records.map { |r| r[relation.foreign_key_target] }
+                )
+              ]
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class Page
+        attr_reader :offset, :limit
+
+        def initialize(offset:, limit:)
+          @offset = offset
+          @limit = limit
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class Projection < Array
+        include ForestAdminDatasourceToolkit::Utils
+        def with_pks(collection)
+          ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection).each do |key|
+            push(key) unless include?(key)
+          end
+
+          relations.each do |relation, projection|
+            schema = collection.fields[relation]
+            association = collection.datasource.collection(schema.foreign_collection)
+            projection_with_pks = projection.with_pks(association).nest(prefix: relation)
+
+            projection_with_pks.each { |field| push(field) unless include?(field) }
+          end
+
+          self
+        end
+
+        def columns
+          reject { |field| field.include?(':') }
+        end
+
+        def relations
+          each_with_object({}) do |path, memo|
+            next unless path.include?(':')
+
+            split_path = path.split(':')
+            relation = split_path[0]
+            memo[relation] = Projection.new([split_path[1]].union(memo[relation] || []))
+          end
+        end
+
+        def nest(prefix: nil)
+          prefix ? Projection.new(map { |path| "#{prefix}:#{path}" }) : self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class ProjectionFactory
+        include ForestAdminDatasourceToolkit::Utils
+        def self.all(collection)
+          projection_fields = collection.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
+                                         .select { |_column_name, relation_column| relation_column.type == 'Column' }
+                                         .keys
+                                         .map { |relation_column_name| "#{column_name}:#{relation_column_name}" }
+
+              memo += relation_columns
+            end
+
+            memo
+          end
+
+          Projection.new projection_fields
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/datasource.rb

@@ -0,0 +1,29 @@
+module ForestAdminDatasourceToolkit
+  class Datasource < Components::Contracts::DatasourceContract
+    attr_reader :collections, :charts
+
+    def initialize
+      super
+      @charts = {}
+      @collections = {}
+    end
+
+    def collection(name)
+      raise Exceptions::ForestException, "Collection #{name} not found." unless @collections.key? name
+
+      @collections[name]
+    end
+
+    def add_collection(collection)
+      if @collections.key? collection.name
+        raise Exceptions::ForestException, "Collection #{collection.name} already defined in datasource"
+      end
+
+      @collections[collection.name] = collection
+    end
+
+    def render_chart(_caller, name)
+      raise Exceptions::ForestException, "No chart named #{name} exists on this datasource."
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/exceptions/forest_exception.rb

@@ -0,0 +1,10 @@
+module ForestAdminDatasourceToolkit
+  module Exceptions
+    class ForestException < RuntimeError
+      def initialize(msg = '')
+        msg = "🌳🌳🌳 #{msg}"
+        super msg
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/column_schema.rb

@@ -0,0 +1,34 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    class ColumnSchema
+      attr_reader :is_primary_key, :default_value, :enum_values, :type
+
+      attr_accessor :is_read_only,
+                    :is_sortable,
+                    :validations,
+                    :filter_operators,
+                    :column_type
+
+      def initialize(
+        column_type:,
+        filter_operators: [],
+        is_primary_key: false,
+        is_read_only: false,
+        is_sortable: false,
+        default_value: nil,
+        enum_values: [],
+        validations: []
+      )
+        @column_type = column_type
+        @filter_operators = filter_operators
+        @is_primary_key = is_primary_key
+        @is_read_only = is_read_only
+        @is_sortable = is_sortable
+        @default_value = default_value
+        @enum_values = enum_values
+        @validations = validations
+        @type = 'Column'
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/primitive_type.rb

@@ -0,0 +1,31 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    class PrimitiveType
+      BINARY = 'Binary'.freeze
+
+      BOOLEAN = 'Boolean'.freeze
+
+      DATE = 'Date'.freeze
+
+      DATEONLY = 'Dateonly'.freeze
+
+      ENUM = 'Enum'.freeze
+
+      JSON = 'Json'.freeze
+
+      NUMBER = 'Number'.freeze
+
+      POINT = 'Point'.freeze
+
+      STRING = 'String'.freeze
+
+      TIMEONLY = 'Timeonly'.freeze
+
+      UUID = 'Uuid'.freeze
+
+      def self.all
+        constants
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/relation_schema.rb

@@ -0,0 +1,13 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    class RelationSchema
+      attr_accessor :foreign_collection
+      attr_reader :type
+
+      def initialize(foreign_collection, type)
+        @foreign_collection = foreign_collection
+        @type = type
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/relations/many_to_many_schema.rb

@@ -0,0 +1,26 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    module Relations
+      class ManyToManySchema < RelationSchema
+        attr_accessor :origin_key, :through_collection, :foreign_key
+        attr_reader :origin_key_target, :foreign_key_target
+
+        def initialize(
+          origin_key:,
+          origin_key_target:,
+          foreign_key:,
+          foreign_key_target:,
+          foreign_collection:,
+          through_collection:
+        )
+          super(foreign_collection, 'ManyToMany')
+          @origin_key = origin_key
+          @origin_key_target = origin_key_target
+          @through_collection = through_collection
+          @foreign_key = foreign_key
+          @foreign_key_target = foreign_key_target
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/relations/many_to_one_schema.rb

@@ -0,0 +1,16 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    module Relations
+      class ManyToOneSchema < RelationSchema
+        attr_accessor :foreign_key
+        attr_reader :foreign_key_target
+
+        def initialize(foreign_key:, foreign_key_target:, foreign_collection:)
+          super(foreign_collection, 'ManyToOne')
+          @foreign_key = foreign_key
+          @foreign_key_target = foreign_key_target
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/relations/one_to_many_schema.rb

@@ -0,0 +1,16 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    module Relations
+      class OneToManySchema < RelationSchema
+        attr_accessor :origin_key
+        attr_reader :origin_key_target
+
+        def initialize(origin_key:, origin_key_target:, foreign_collection:)
+          super(foreign_collection, 'OneToMany')
+          @origin_key = origin_key
+          @origin_key_target = origin_key_target
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/relations/one_to_one_schema.rb

@@ -0,0 +1,16 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    module Relations
+      class OneToOneSchema < RelationSchema
+        attr_accessor :origin_key
+        attr_reader :origin_key_target
+
+        def initialize(origin_key:, origin_key_target:, foreign_collection:)
+          super(foreign_collection, 'OneToOne')
+          @origin_key = origin_key
+          @origin_key_target = origin_key_target
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/utils/collection.rb

@@ -0,0 +1,162 @@
+module ForestAdminDatasourceToolkit
+  module Utils
+    class Collection
+      include ForestAdminDatasourceToolkit::Components::Query
+      include ForestAdminDatasourceToolkit::Schema
+      include ForestAdminDatasourceToolkit::Schema::Relations
+      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)
+
+        inverse = foreign_collection.fields.select do |_name, field|
+          field.is_a?(RelationSchema) &&
+            field.foreign_collection == collection.name &&
+            (
+              (field.is_a?(ManyToManySchema) &&
+                relation_field.is_a?(ManyToManySchema) &&
+                many_to_many_inverse?(field, relation_field)) ||
+              (field.is_a?(ManyToOneSchema) &&
+                (relation_field.is_a?(OneToOneSchema) || relation_field.is_a?(OneToManySchema)) &&
+                many_to_one_inverse?(field, relation_field)) ||
+              ((field.is_a?(OneToOneSchema) || field.is_a?(OneToManySchema)) &&
+                relation_field.is_a?(ManyToOneSchema) && other_inverse?(field, relation_field))
+            )
+        end.keys.first
+
+        inverse || nil
+      end
+
+      def self.many_to_many_inverse?(field, relation_field)
+        field.is_a?(ManyToManySchema) &&
+          relation_field.is_a?(ManyToManySchema) &&
+          field.origin_key == relation_field.foreign_key &&
+          field.through_collection == relation_field.through_collection &&
+          field.foreign_key == relation_field.origin_key
+      end
+
+      def self.many_to_one_inverse?(field, relation_field)
+        field.is_a?(ManyToOneSchema) &&
+          (relation_field.is_a?(OneToManySchema) ||
+            relation_field.is_a?(OneToOneSchema)) &&
+          field.foreign_key == relation_field.origin_key
+      end
+
+      def self.other_inverse?(field, relation_field)
+        (field.is_a?(OneToManySchema) || field.is_a?(OneToOneSchema)) &&
+          relation_field.is_a?(ManyToOneSchema) &&
+          field.origin_key == relation_field.foreign_key
+      end
+
+      def self.get_field_schema(collection, field_name)
+        fields = collection.fields
+        unless field_name.include?(':')
+          raise ForestException, "Column not found #{collection.name}.#{field_name}" unless fields.key?(field_name)
+
+          return fields[field_name]
+        end
+
+        association_name = field_name.split(':')[0]
+        relation_schema = fields[association_name]
+
+        raise ForestException, "Relation not found #{collection.name}.#{association_name}" unless relation_schema
+
+        if relation_schema.type != 'ManyToOne' && relation_schema.type != 'OneToOne'
+          raise ForestException, "Unexpected field type #{relation_schema.type}: #{collection.name}.#{association_name}"
+        end
+
+        get_field_schema(
+          collection.datasource.collection(relation_schema.foreign_collection), field_name.split(':')[1..].join(':')
+        )
+      end
+
+      def self.get_value(collection, caller, id, field)
+        if id.is_a? Array
+          index = Schema.primary_keys(collection).index(field)
+
+          return id[index] if index
+        elsif Schema.primary_keys(collection).include?(field)
+          return id[field]
+        end
+
+        record = collection.list(
+          caller,
+          ForestAdminDatasourceToolkit::Components::Query::Filter.new(condition_tree: ConditionTree::ConditionTreeFactory.match_ids(collection, [id])),
+          Projection.new([field])
+        )
+
+        record[field]
+      end
+
+      def self.get_through_target(collection, relation_name)
+        relation = collection.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|
+          if field.is_a?(ManyToOneSchema) &&
+             field.foreign_collection == relation.foreign_collection &&
+             field.foreign_key == relation.foreign_key &&
+             field.foreign_key_target == relation.foreign_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)
+
+        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)
+            records = through_collection.list(
+              caller,
+              FilterFactory.make_through_filter(collection, id, relation_name, caller, foreign_filter),
+              projection.nest(prefix: foreign_relation)
+            )
+
+            return records.map { |r| r.try(foreign_relation) }
+          end
+        end
+
+        foreign_collection.list(
+          caller,
+          FilterFactory.make_foreign_filter(collection, id, relation_name, caller, foreign_filter),
+          projection
+        )
+      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)
+
+        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)
+
+            return through_collection.aggregate(
+              caller,
+              FilterFactory.make_through_filter(collection, id, relation_name, caller, foreign_filter),
+              aggregation,
+              limit
+            )
+          end
+        end
+
+        foreign_collection.aggregate(
+          caller,
+          FilterFactory.make_foreign_filter(collection, id, relation_name, caller, foreign_filter),
+          aggregation,
+          limit
+        )
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/utils/record.rb

@@ -0,0 +1,20 @@
+module ForestAdminDatasourceToolkit
+  module Utils
+    class Record
+      def self.primary_keys(collection, record)
+        Schema.primary_keys(collection).map do |pk|
+          record[pk] || raise(ForestAdminDatasourceToolkit::Exceptions::ForestException, "Missing primary key: #{pk}")
+        end
+      end
+
+      def self.field_value(record, field)
+        path = field.split(':')
+        current = record
+
+        current = current[path.shift] while path.length.positive? && current
+
+        path.empty? ? current : nil
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/utils/schema.rb

@@ -0,0 +1,42 @@
+module ForestAdminDatasourceToolkit
+  module Utils
+    class Schema
+      def self.foreign_key?(collection, name)
+        field = collection.fields[name]
+
+        field.type == 'Column' &&
+          collection.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.type == 'Column' && field.is_primary_key
+      end
+
+      def self.primary_keys(collection)
+        collection.fields.keys.select do |field_name|
+          field = collection.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)
+          raise Exceptions::ForestException, "Relation #{relation_name} not found"
+        end
+
+        relation = collection.fields[relation_name]
+
+        if relation.type != 'OneToMany' && relation.type != 'ManyToMany'
+          raise Exceptions::ForestException,
+                "Relation #{relation_name} has invalid type should be one of OneToMany or ManyToMany."
+        end
+
+        relation
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/version.rb

@@ -0,0 +1,3 @@
+module ForestAdminDatasourceToolkit
+  VERSION = "1.0.0-beta.21"
+end