forest_admin_datasource_customizer 1.0.0.pre.beta.21 → 1.0.0.pre.beta.57

data/lib/forest_admin_datasource_customizer/decorators/rename_field/rename_field_collection_decorator.rb

@@ -0,0 +1,190 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module RenameField
+      class RenameFieldCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        attr_accessor :from_child_collection, :to_child_collection
+
+        def initialize(child_collection, datasource)
+          super
+          @from_child_collection = {}
+          @to_child_collection = {}
+        end
+
+        def rename_field(current_name, new_name)
+          unless schema[:fields][current_name]
+            raise ForestAdminDatasourceToolkit::Exceptions::ForestException, "No such field '#{current_name}'"
+          end
+
+          initial_name = current_name
+
+          ForestAdminDatasourceToolkit::Validations::FieldValidator.validate_name(name, new_name)
+
+          # Revert previous renaming (avoids conflicts and need to recurse on @to_child_collection).
+          if to_child_collection[current_name]
+            child_name = to_child_collection[current_name]
+            to_child_collection.delete(current_name)
+            from_child_collection.delete(child_name)
+            initial_name = child_name
+            mark_all_schema_as_dirty
+          end
+
+          # Do not update arrays if renaming is a no-op (ie: customer is cancelling a previous rename)
+          return unless initial_name != new_name
+
+          from_child_collection[initial_name] = new_name
+          to_child_collection[new_name] = initial_name
+          mark_all_schema_as_dirty
+        end
+
+        def refine_schema(sub_schema)
+          fields = {}
+
+          sub_schema[:fields].each do |old_name, old_schema|
+            case old_schema.type
+            when 'ManyToOne'
+              old_schema.foreign_key = from_child_collection[old_schema.foreign_key] || old_schema.foreign_key
+            when 'OneToMany', 'OneToOne'
+              relation = datasource.get_collection(old_schema.foreign_collection)
+              old_schema.origin_key = relation.from_child_collection[old_schema.origin_key] || old_schema.origin_key
+            when 'ManyToMany'
+              through = datasource.get_collection(old_schema.through_collection)
+              old_schema.foreign_key = through.from_child_collection[old_schema.foreign_key] || old_schema.foreign_key
+              old_schema.origin_key = through.from_child_collection[old_schema.origin_key] || old_schema.origin_key
+            end
+
+            fields[from_child_collection[old_name] || old_name] = old_schema
+          end
+
+          sub_schema[:fields] = fields
+
+          sub_schema
+        end
+
+        def refine_filter(_caller, filter = nil)
+          filter&.override(
+            condition_tree: filter.condition_tree&.replace_fields do |field|
+              path_to_child_collection(field)
+            end,
+            sort: filter.sort&.replace_clauses do |clause|
+              {
+                field: path_to_child_collection(clause[:field]),
+                ascending: clause[:ascending]
+              }
+            end
+          )
+        end
+
+        def create(caller, data)
+          record = @child_collection.create(
+            caller,
+            record_to_child_collection(data)
+          )
+
+          record_from_child_collection(record)
+        end
+
+        def list(caller, filter, projection)
+          child_projection = projection.replace { |field| path_to_child_collection(field) }
+          records = @child_collection.list(caller, filter, child_projection)
+          return records if child_projection == projection
+
+          records.map { |record| record_from_child_collection(record) }
+        end
+
+        def update(caller, filter, patch)
+          @child_collection.update(caller, filter, record_to_child_collection(patch))
+        end
+
+        def aggregate(caller, filter, aggregation, limit = nil)
+          rows = @child_collection.aggregate(
+            caller,
+            filter,
+            aggregation.replace_fields { |field| path_to_child_collection(field) },
+            limit
+          )
+
+          rows.map do |row|
+            {
+              'value' => row['value'],
+              'group' => row['group']&.reduce({}) do |memo, group|
+                path, value = group
+                memo.merge({ path_from_child_collection(path) => value })
+              end
+            }
+          end
+        end
+
+        # rubocop:disable Lint/UselessMethodDefinition
+        def mark_schema_as_dirty
+          super
+        end
+        # rubocop:enable Lint/UselessMethodDefinition
+
+        def mark_all_schema_as_dirty
+          datasource.collections.each_value(&:mark_schema_as_dirty)
+        end
+
+        # Convert field path from child collection to this collection
+        def path_from_child_collection(path)
+          if path.include?(':')
+            paths = path.split(':')
+            child_field = paths[0]
+            relation_name = from_child_collection[child_field] || child_field
+            relation_schema = schema[:fields][relation_name]
+            relation = datasource.get_collection(relation_schema.foreign_collection)
+
+            return "#{relation_name}:#{relation.path_from_child_collection(paths[1])}"
+          end
+
+          from_child_collection[path] ||= path
+        end
+
+        # Convert field path from this collection to child collection
+        def path_to_child_collection(path)
+          if path.include?(':')
+            paths = path.split(':')
+            relation_name = paths[0]
+            relation_schema = schema[:fields][relation_name]
+            relation = datasource.get_collection(relation_schema.foreign_collection)
+            child_field = to_child_collection[relation_name] || relation_name
+
+            return "#{child_field}:#{relation.path_to_child_collection(paths[1])}"
+          end
+
+          to_child_collection[path] ||= path
+        end
+
+        # Convert record from this collection to the child collection
+        def record_to_child_collection(record)
+          child_record = {}
+          record.each do |field, value|
+            child_record[to_child_collection[field] || field] = value
+          end
+
+          child_record
+        end
+
+        def record_from_child_collection(child_record)
+          record = {}
+          child_record.each do |child_field, value|
+            field = from_child_collection[child_field] || child_field
+            field_schema = schema[:fields][field]
+
+            # Perform the mapping, recurse for relations
+            if field_schema.type == 'Column' || value.nil?
+              record[field] = value
+            else
+              relation = datasource.get_collection(field_schema.foreign_collection)
+              record[field] = relation.record_from_child_collection(value)
+            end
+          end
+
+          record
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Schema
+      class SchemaCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::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_customizer/decorators/search/search_collection_decorator.rb

@@ -0,0 +1,135 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Search
+      class SearchCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Schema
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        def initialize(child_collection, datasource)
+          super
+          @replacer = nil
+        end
+
+        def replace_search(replacer)
+          @replacer = replacer
+        end
+
+        def refine_schema(sub_schema)
+          sub_schema.merge({ searchable: true })
+        end
+
+        def refine_filter(caller, filter)
+          # Search string is not significant
+          return filter.override({ search: nil }) if !filter || !filter.search || filter.search.strip&.length&.zero?
+
+          # Implement search ourselves
+          if @replacer || !@child_collection.schema[:searchable]
+            ctx = ForestAdminDatasourceCustomizer::Context::CollectionCustomizationContext.new(self, caller)
+            tree = default_replacer(filter.search, filter.search_extended)
+
+            if @replacer
+              plain_tree = @replacer.call(filter.search, filter.search_extended, ctx)
+              tree = ConditionTreeFactory.from_plain_object(plain_tree)
+            end
+
+            # Note that if no fields are searchable with the provided searchString, the conditions
+            # array might be empty, which will create a condition returning zero records
+            # (this is the desired behavior).
+            return filter.override({
+                                     condition_tree: ConditionTreeFactory.intersect([filter.condition_tree, tree]),
+                                     search: nil
+                                   })
+          end
+
+          # Let sub-collection deal with the search
+          filter
+        end
+
+        private
+
+        def default_replacer(search, extended)
+          searchable_fields = get_fields(@child_collection, extended)
+
+          conditions = searchable_fields.map do |field, schema|
+            build_condition(field, schema, search)
+          end
+
+          ConditionTreeFactory.union(conditions)
+        end
+
+        def build_condition(field, schema, search_string)
+          column_type = schema.column_type
+          enum_values = schema.enum_values
+          filter_operators = schema.filter_operators
+          is_number = number?(search_string)
+          is_uuid = uuid?(search_string)
+
+          if column_type == PrimitiveType::NUMBER && is_number && filter_operators&.include?(Operators::EQUAL)
+            return Nodes::ConditionTreeLeaf.new(field, Operators::EQUAL, search_string.to_f)
+          end
+
+          if column_type == PrimitiveType::ENUM && filter_operators&.include?(Operators::EQUAL)
+            search_value = lenient_find(enum_values, search_string)
+
+            return Nodes::ConditionTreeLeaf.new(field, Operators::EQUAL, search_value) if search_value
+          end
+
+          if column_type == PrimitiveType::STRING
+            is_case_sensitive = !search_string.casecmp(search_string).zero?
+            supports_i_contains = filter_operators&.include?(Operators::I_CONTAINS)
+            supports_contains = filter_operators&.include?(Operators::CONTAINS)
+            supports_equal = filter_operators&.include?(Operators::EQUAL)
+
+            operator = nil
+            if supports_i_contains && (is_case_sensitive || !supports_contains)
+              operator = Operators::I_CONTAINS
+            elsif supports_contains
+              operator = Operators::CONTAINS
+            elsif supports_equal
+              operator = Operators::EQUAL
+            end
+
+            return Nodes::ConditionTreeLeaf.new(field, operator, search_string) if operator
+          end
+
+          if column_type == PrimitiveType::UUID && is_uuid && filter_operators&.include?(Operators::EQUAL)
+            return Nodes::ConditionTreeLeaf.new(field, Operators::EQUAL, search_string)
+          end
+
+          nil
+        end
+
+        def get_fields(collection, extended)
+          fields = []
+          collection.schema[:fields].each do |name, field|
+            fields.push([name, field]) if field.type == 'Column'
+
+            next unless extended && (field.type == 'ManyToOne' || field.type == 'OneToOne')
+
+            related = collection.datasource.get_collection(field.foreign_collection)
+
+            related.schema[:fields].each do |sub_name, sub_field|
+              fields.push(["#{name}:#{sub_name}", sub_field]) if sub_field.type == 'Column'
+            end
+          end
+
+          fields
+        end
+
+        def lenient_find(haystack, needle)
+          haystack&.find { |v| v == needle.strip } || haystack&.find { |v| v.downcase == needle.downcase.strip }
+        end
+
+        def uuid?(value)
+          value.to_s.downcase.match?(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i)
+        end
+
+        def number?(value)
+          true if Float(value)
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/segment/segment_collection_decorator.rb

@@ -0,0 +1,60 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Segment
+      class SegmentCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Validations
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        attr_reader :segments
+
+        def initialize(child_collection, datasource)
+          super
+          @segments = {}
+        end
+
+        def add_segment(name, definition)
+          @segments[name] = definition
+
+          mark_schema_as_dirty
+        end
+
+        def refine_schema(sub_schema)
+          sub_schema[:segments] = sub_schema[:segments].merge(@segments)
+
+          sub_schema
+        end
+
+        def refine_filter(caller, filter = nil)
+          return nil unless filter
+
+          condition_tree = filter.condition_tree
+          segment = filter.segment
+
+          if segment && @segments.key?(segment)
+            definition = @segments[segment]
+
+            result = if definition.respond_to? :call
+                       definition.call(Context::CollectionCustomizationContext.new(self, caller))
+                     else
+                       definition
+                     end
+
+            condition_tree_segment = if result.is_a? Nodes::ConditionTree
+                                       result
+                                     else
+                                       ConditionTreeFactory.from_plain_object(result)
+                                     end
+
+            ConditionTreeValidator.validate(condition_tree_segment, self)
+
+            condition_tree = ConditionTreeFactory.intersect([condition_tree_segment, filter.condition_tree])
+            segment = nil
+          end
+
+          filter.override(condition_tree: condition_tree, segment: segment)
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/sort/sort_collection_decorator.rb

@@ -0,0 +1,127 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Sort
+      class SortCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Exceptions
+        include ForestAdminDatasourceToolkit::Validations
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Utils
+
+        attr_reader :sorts
+
+        def initialize(child_collection, datasource)
+          super
+          @sorts = {}
+        end
+
+        def emulate_field_sorting(name)
+          replace_or_emulate_field_sorting(name, nil)
+        end
+
+        def replace_field_sorting(name, equivalent_sort)
+          if equivalent_sort.nil?
+            raise ForestException, 'A new sorting method should be provided to replace field sorting'
+          end
+
+          replace_or_emulate_field_sorting(name, equivalent_sort)
+        end
+
+        def list(caller, filter = nil, projection = nil)
+          child_filter = filter.override(sort: filter.sort&.replace_clauses do |clause|
+                                                 rewrite_plain_sort_clause(clause)
+                                               end)
+
+          if child_filter.sort.nil? || child_filter.sort.none? { |clause| emulated?(clause[:field]) }
+            return child_collection.list(caller, child_filter, projection)
+          end
+
+          # Fetch the whole collection, but only with the fields we need to sort
+          reference_records = child_collection.list(caller, child_filter.override(sort: nil, page: nil),
+                                                    child_filter.sort.projection.with_pks(self))
+          reference_records = child_filter.sort.apply(reference_records)
+          reference_records = child_filter.page.apply(reference_records) if child_filter.page
+
+          # We now have the information we need to sort by the field
+          new_filter = Filter.new(condition_tree: ConditionTree::ConditionTreeFactory.match_records(schema,
+                                                                                                    reference_records))
+
+          records = child_collection.list(caller, new_filter, projection.with_pks(self))
+          records = sort_records(reference_records, records)
+
+          projection.apply(records)
+        end
+
+        def refine_schema(child_schema)
+          child_schema[:fields].each do |name, schema|
+            if schema.type == 'Column'
+              schema.is_sortable = true if @sorts[name].nil?
+              child_schema[:fields][name] = schema
+            end
+          end
+
+          child_schema
+        end
+
+        def rewrite_plain_sort_clause(clause)
+          # Order by is targeting a field on another collection => recurse.
+          if clause[:field].include?(':')
+            prefix = clause[:field].split(':')[0]
+            schema = self.schema[:fields][prefix]
+            association = datasource.get_collection(schema.foreign_collection)
+
+            return ForestAdminDatasourceToolkit::Components::Query::Sort.new([clause])
+                                                                        .unnest
+                                                                        .replace_clauses { |sub_clause| association.rewrite_plain_sort_clause(sub_clause) }
+                                                                        .nest(prefix)
+          end
+
+          # Field that we own: recursively replace using equivalent sort
+          equivalent_sort = @sorts[clause[:field]]
+
+          if equivalent_sort
+            equivalent_sort = equivalent_sort.inverse unless clause[:ascending]
+
+            return equivalent_sort.replace_clauses { |sub_clause| rewrite_plain_sort_clause(sub_clause) }
+          end
+
+          ForestAdminDatasourceToolkit::Components::Query::Sort.new([clause])
+        end
+
+        def emulated?(path)
+          index = path.index(':')
+          return @sorts[path] if index.nil?
+
+          foreign_collection = schema[:fields][path[0, index]].foreign_collection
+          association = datasource.get_collection(foreign_collection)
+
+          association.emulated?(path[index + 1, path.length - index - 1])
+        end
+
+        private
+
+        def replace_or_emulate_field_sorting(name, equivalent_sort)
+          FieldValidator.validate(self, name)
+          @sorts[name] =
+            equivalent_sort ? ForestAdminDatasourceToolkit::Components::Query::Sort.new(equivalent_sort) : nil
+          mark_schema_as_dirty
+        end
+
+        def sort_records(reference_records, records)
+          position_by_id = {}
+          sorted = Array.new(records.length)
+
+          reference_records.each_with_index do |record, index|
+            position_by_id[Record.primary_keys(schema, record).join('|')] = index
+          end
+
+          records.each do |record|
+            id = Record.primary_keys(schema, record).join('|')
+            sorted[position_by_id[id]] = record
+          end
+
+          sorted
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/validation/validation_collection_decorator.rb

@@ -0,0 +1,82 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Validation
+      class ValidationCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Validations
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+        include ForestAdminDatasourceToolkit::Exceptions
+        attr_reader :validation
+
+        def initialize(child_collection, datasource)
+          super
+          @validation = {}
+        end
+
+        def add_validation(name, validation)
+          FieldValidator.validate(self, name)
+
+          field = @child_collection.schema[:fields][name]
+          if field.nil? || field.type != 'Column'
+            raise ForestException,
+                  'Cannot add validators on a relation, use the foreign key instead'
+          end
+          raise ForestException, 'Cannot add validators on a readonly field' if field.is_read_only
+
+          @validation[name] ||= []
+          @validation[name].push(validation)
+          mark_schema_as_dirty
+        end
+
+        def create(caller, data)
+          data.each { |record| validate(record, caller.timezone, true) }
+          child_collection.create(caller, data)
+        end
+
+        def update(caller, filter, patch)
+          validate(patch, caller.timezone, false)
+          child_collection.update(caller, filter, patch)
+        end
+
+        def refine_schema(child_schema)
+          @validation.each do |name, rules|
+            field = child_schema[:fields][name]
+            field.validations = (field.validations || []).concat(rules)
+            child_schema[:fields][name] = field
+          end
+
+          child_schema
+        end
+
+        private
+
+        def validate(record, timezone, all_fields)
+          @validation.each do |name, rules|
+            next unless all_fields || record.key?(name)
+
+            # When setting a field to nil, only the "Present" validator is relevant
+            applicable_rules = record[name].nil? ? rules.select { |r| r[:operator] == Operators::PRESENT } : rules
+
+            applicable_rules.each do |validator|
+              raw_leaf = { field: name }.merge(validator)
+              tree = ConditionTreeFactory.from_plain_object(raw_leaf)
+              next if tree.match(record, self, timezone)
+
+              message = "#{name} failed validation rule :"
+              rule = if validator.key?(:value)
+                       "#{validator[:operator]}(#{if validator[:value].is_a?(Array)
+                                                    validator[:value].join(",")
+                                                  else
+                                                    validator[:value]
+                                                  end})"
+                     else
+                       validator[:operator]
+                     end
+
+              raise ValidationError, "#{message} #{rule}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/write/create_relations/create_relations_collection_decorator.rb

@@ -0,0 +1,75 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Write
+      module CreateRelations
+        class CreateRelationsCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+          include ForestAdminDatasourceToolkit::Components::Query
+          include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+          include ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes
+          def create(caller, data)
+            # Step 1: Remove all relations from records, and store them in a map
+            # Note: the extractRelations method modifies the records array in place!
+            records_by_relation = extract_relations(data)
+
+            # Step 2: Create the many-to-one relations, and put the foreign keys in the records
+            records_by_relation.each do |key, entries|
+              create_many_to_one_relation(caller, data, key, entries) if schema[:fields][key].type == 'ManyToOne'
+            end
+
+            # Step 3: Create the records
+            records_with_pk = child_collection.create(caller, data)
+
+            # Step 4: Create the one-to-one relations
+            # Note: the create_one_to_one_relation method modifies the records_with_pk array in place!
+            records_by_relation.each do |key, entries|
+              if schema[:fields][key].type == 'OneToOne'
+                create_one_to_one_relation(caller, records_with_pk, key, entries)
+              end
+            end
+
+            records_with_pk
+          end
+
+          private
+
+          def extract_relations(record)
+            records_by_relation = {}
+
+            record.each do |key, value|
+              next unless schema[:fields][key].type != 'Column'
+
+              value.each do |sub_key, sub_record|
+                records_by_relation[key] ||= {}
+                records_by_relation[key][sub_key] = sub_record
+              end
+              record.delete(key)
+            end
+
+            records_by_relation
+          end
+
+          def create_many_to_one_relation(caller, records, key, entries)
+            field_schema = schema[:fields][key]
+            relation = datasource.get_collection(field_schema.foreign_collection)
+
+            if records.key?(field_schema.foreign_key)
+              value = records[field_schema.foreign_key]
+              condition_tree = ConditionTreeLeaf.new(field_schema.foreign_key_target, Operators::EQUAL, value)
+              relation.update(caller, Filter.new(condition_tree: condition_tree), entries)
+            else
+              related_record = relation.create(caller, entries)
+              records[field_schema.foreign_key] = related_record[field_schema.foreign_key_target]
+            end
+          end
+
+          def create_one_to_one_relation(caller, records, key, entries)
+            field_schema = schema[:fields][key]
+            relation = datasource.get_collection(field_schema.foreign_collection)
+
+            relation.create(caller, entries.merge(field_schema.origin_key => records[field_schema.origin_key_target]))
+          end
+        end
+      end
+    end
+  end
+end