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

data/lib/forest_admin_datasource_customizer/decorators/computed/utils/computed_field.rb

@@ -0,0 +1,74 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Computed
+      module Utils
+        class ComputedField
+          include ForestAdminDatasourceToolkit::Components::Query
+
+          def self.compute_field(ctx, computed, computed_dependencies, flatten)
+            transform_unique_values(
+              Flattener.un_flatten(
+                flatten,
+                Projection.new(computed_dependencies)
+              ),
+              ->(unique_partials) { computed.get_values(unique_partials, ctx) }
+            )
+          end
+
+          def self.queue_field(ctx, collection, new_path, paths, flatten)
+            return if paths.include?(new_path)
+
+            computed = collection.get_computed(new_path)
+            nested_dependencies = Projection.new(computed.dependencies)
+                                            .nest(prefix: new_path.include?(':') ? new_path.split(':')[0] : nil)
+
+            nested_dependencies.each do |path|
+              queue_field(ctx, collection, path, paths, flatten)
+            end
+
+            dependency_values = nested_dependencies.map { |path| flatten[paths.index(path)] }
+            paths.push(new_path)
+
+            flatten << compute_field(ctx, computed, computed.dependencies, dependency_values)
+          end
+
+          def self.compute_from_records(ctx, collection, records_projection, desired_projection, records)
+            paths = records_projection.clone
+            flatten = Flattener.flatten(records, paths)
+
+            desired_projection.each do |path|
+              queue_field(ctx, collection, path, paths, flatten)
+            end
+
+            Flattener.un_flatten(desired_projection.map { |path| flatten[paths.index(path)] }, desired_projection)
+          end
+
+          def self.transform_unique_values(inputs, callback)
+            indexes = {}
+            mapping = []
+            unique_inputs = []
+
+            inputs.each do |input|
+              if input
+                hash = Digest::SHA1.hexdigest(input.to_s)
+
+                if indexes[hash].nil?
+                  indexes[hash] = unique_inputs.length
+                  unique_inputs.push(input)
+                end
+
+                mapping.push(indexes[hash])
+              else
+                mapping.push(-1)
+              end
+            end
+
+            unique_outputs = callback.call(unique_inputs)
+
+            mapping.map { |index| index == -1 ? nil : unique_outputs[index] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/computed/utils/flattener.rb

@@ -0,0 +1,49 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Computed
+      module Utils
+        class Flattener
+          def self.flatten(records, projection)
+            projection.map do |field|
+              records.map { |record| ForestAdminDatasourceToolkit::Utils::Record.field_value(record, field) }
+            end
+          end
+
+          def self.un_flatten(flatten, projection)
+            num_records = flatten[0]&.length || 0
+            records = []
+
+            (0...num_records).each do |record_index|
+              records[record_index] = {}
+
+              projection.each_with_index do |path, path_index|
+                parts = path.split(':').reject { |part| part.nil? || part.empty? }
+                value = flatten[path_index][record_index]
+
+                # Ignore undefined values.
+                next if value.nil?
+
+                # Set all others (including null)
+                record = records[record_index]
+
+                (0...parts.length).each do |part_index|
+                  part = parts[part_index]
+
+                  if part_index == parts.length - 1
+                    record[part] = value
+                  elsif record[part].nil?
+                    record[part] = {}
+                  end
+
+                  record = record[part]
+                end
+              end
+            end
+
+            records
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/decorators_stack.rb

@@ -3,11 +3,40 @@ module ForestAdminDatasourceCustomizer
     class DecoratorsStack
       include ForestAdminDatasourceToolkit::Decorators
 
-      attr_reader :datasource, :empty
+      attr_reader :datasource, :schema, :search, :early_computed, :late_computed, :action, :relation, :late_op_emulate,
+                  :early_op_emulate, :validation, :sort, :rename_field, :publication, :write, :chart, :hook, :segment,
+                  :binary, :override
 
       def initialize(datasource)
+        @customizations = []
+
         last = datasource
-        last = @empty = DatasourceDecorator.new(last, Empty::EmptyCollectionDecorator)
+        last = @override = DatasourceDecorator.new(last, Override::OverrideCollectionDecorator)
+        last = DatasourceDecorator.new(last, Empty::EmptyCollectionDecorator)
+        last = DatasourceDecorator.new(last, OperatorsEquivalence::OperatorsEquivalenceCollectionDecorator)
+
+        last = @early_computed = DatasourceDecorator.new(last, Computed::ComputeCollectionDecorator)
+        last = @early_op_emulate = DatasourceDecorator.new(last, OperatorsEmulate::OperatorsEmulateCollectionDecorator)
+        last = DatasourceDecorator.new(last, OperatorsEquivalence::OperatorsEquivalenceCollectionDecorator)
+        last = @relation = DatasourceDecorator.new(last, Relation::RelationCollectionDecorator)
+        last = @late_computed = DatasourceDecorator.new(last, Computed::ComputeCollectionDecorator)
+        last = @late_op_emulate = DatasourceDecorator.new(last, OperatorsEmulate::OperatorsEmulateCollectionDecorator)
+        last = DatasourceDecorator.new(last, OperatorsEquivalence::OperatorsEquivalenceCollectionDecorator)
+
+        last = @search = DatasourceDecorator.new(last, Search::SearchCollectionDecorator)
+        last = @segment = DatasourceDecorator.new(last, Segment::SegmentCollectionDecorator)
+        last = @sort = DatasourceDecorator.new(last, Sort::SortCollectionDecorator)
+
+        last = @chart = Chart::ChartDatasourceDecorator.new(last)
+        last = @action = DatasourceDecorator.new(last, Action::ActionCollectionDecorator)
+        last = @schema = DatasourceDecorator.new(last, Schema::SchemaCollectionDecorator)
+        last = @write = Write::WriteDatasourceDecorator.new(last)
+        last = @hook = DatasourceDecorator.new(last, Hook::HookCollectionDecorator)
+        last = @validation = DatasourceDecorator.new(last, Validation::ValidationCollectionDecorator)
+        last = @binary = DatasourceDecorator.new(last, Binary::BinaryCollectionDecorator)
+
+        last = @publication = Publication::PublicationDatasourceDecorator.new(last)
+        last = @rename_field = DatasourceDecorator.new(last, RenameField::RenameFieldCollectionDecorator)
         @datasource = last
       end
 
@@ -21,11 +50,11 @@ module ForestAdminDatasourceCustomizer
       # This method will be called recursively and clears the queue at each recursion to ensure
       # that all customizations are applied in the right order.
       def apply_queued_customizations(logger)
-        queued_customizations = @customizations.pop
+        queued_customizations = @customizations.clone
         @customizations = []
 
         while queued_customizations.length.positive?
-          queued_customizations.shift.call(logger)
+          queued_customizations.shift.call
           apply_queued_customizations(logger)
         end
       end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/after/hook_after_aggregate_context.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module After
+          class HookAfterAggregateContext < Hook::Context::Before::HookBeforeAggregateContext
+            attr_reader :aggregate_result
+
+            def initialize(collection, caller, filter, aggregation, aggregate_result, limit = nil)
+              super(collection, caller, filter, aggregation, limit)
+              @aggregate_result = aggregate_result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/after/hook_after_create_context.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module After
+          class HookAfterCreateContext < Hook::Context::Before::HookBeforeCreateContext
+            attr_reader :record
+
+            def initialize(collection, caller, data, record)
+              super(collection, caller, data)
+              @record = record
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/after/hook_after_delete_context.rb

@@ -0,0 +1,12 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module After
+          class HookAfterDeleteContext < Hook::Context::Before::HookBeforeDeleteContext
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/after/hook_after_list_context.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module After
+          class HookAfterListContext < Hook::Context::Before::HookBeforeListContext
+            attr_reader :records
+
+            def initialize(collection, caller, filter, projection, records)
+              super(collection, caller, filter, projection)
+              @records = records
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/after/hook_after_update_context.rb

@@ -0,0 +1,12 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module After
+          class HookAfterUpdateContext < Hook::Context::Before::HookBeforeUpdateContext
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/before/hook_before_aggregate_context.rb

@@ -0,0 +1,20 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module Before
+          class HookBeforeAggregateContext < Hook::Context::HookContext
+            attr_reader :filter, :aggregation, :limit
+
+            def initialize(collection, caller, filter, aggregation, limit = nil)
+              super(collection, caller)
+              @filter = filter
+              @aggregation = aggregation
+              @limit = limit
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/before/hook_before_create_context.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module Before
+          class HookBeforeCreateContext < Hook::Context::HookContext
+            attr_reader :data
+
+            def initialize(collection, caller, data)
+              super(collection, caller)
+              @data = data
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/before/hook_before_delete_context.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module Before
+          class HookBeforeDeleteContext < Hook::Context::HookContext
+            attr_reader :filter
+
+            def initialize(collection, caller, filter)
+              super(collection, caller)
+              @filter = filter
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/before/hook_before_list_context.rb

@@ -0,0 +1,19 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module Before
+          class HookBeforeListContext < Hook::Context::HookContext
+            attr_reader :filter, :projection
+
+            def initialize(collection, caller, filter, projection)
+              super(collection, caller)
+              @filter = filter
+              @projection = projection
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/before/hook_before_update_context.rb

@@ -0,0 +1,19 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        module Before
+          class HookBeforeUpdateContext < Hook::Context::HookContext
+            attr_reader :filter, :patch
+
+            def initialize(collection, caller, filter, patch)
+              super(collection, caller)
+              @filter = filter
+              @patch = patch
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/context/hook_context.rb

@@ -0,0 +1,22 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      module Context
+        class HookContext < ForestAdminDatasourceCustomizer::Context::CollectionCustomizationContext
+          include ForestAdminAgent::Http::Exceptions
+          def raise_validation_error(message)
+            raise ValidationError, message
+          end
+
+          def raise_forbidden_error(message)
+            raise ForbiddenError, message
+          end
+
+          def raise_error(message)
+            raise UnprocessableError, message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/hook_collection_decorator.rb

@@ -0,0 +1,95 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      class HookCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Components
+        include Context
+
+        attr_reader :hooks
+
+        def initialize(child_collection, datasource)
+          super
+          @hooks = {
+            'List' => Hooks.new,
+            'Create' => Hooks.new,
+            'Update' => Hooks.new,
+            'Delete' => Hooks.new,
+            'Aggregate' => Hooks.new
+          }
+        end
+
+        def add_hook(position, type, hook)
+          @hooks[type].add_handler(position, hook)
+        end
+
+        def create(caller, data)
+          before_context = Before::HookBeforeCreateContext.new(@child_collection, caller, data)
+          @hooks['Create'].execute_before(before_context)
+
+          record = @child_collection.create(caller, before_context.data)
+
+          after_context = After::HookAfterCreateContext.new(@child_collection, caller, data, record)
+          @hooks['Create'].execute_after(after_context)
+
+          record
+        end
+
+        def list(caller, filter, projection)
+          before_context = Before::HookBeforeListContext.new(@child_collection, caller, filter, projection)
+          @hooks['List'].execute_before(before_context)
+
+          records = @child_collection.list(caller, before_context.filter, before_context.projection)
+
+          after_context = After::HookAfterListContext.new(@child_collection, caller, filter, projection, records)
+          @hooks['List'].execute_after(after_context)
+
+          records
+        end
+
+        def update(caller, filter, patch)
+          before_context = Before::HookBeforeUpdateContext.new(@child_collection, caller, filter, patch)
+          @hooks['Update'].execute_before(before_context)
+
+          @child_collection.update(caller, before_context.filter, before_context.patch)
+
+          after_context = After::HookAfterUpdateContext.new(@child_collection, caller, filter, patch)
+          @hooks['Update'].execute_after(after_context)
+        end
+
+        def delete(caller, filter)
+          before_context = Before::HookBeforeDeleteContext.new(@child_collection, caller, filter)
+          @hooks['Delete'].execute_before(before_context)
+
+          @child_collection.delete(caller, before_context.filter)
+
+          after_context = After::HookAfterDeleteContext.new(@child_collection, caller, filter)
+          @hooks['Delete'].execute_after(after_context)
+        end
+
+        def aggregate(caller, filter, aggregation, limit = nil)
+          before_context = Before::HookBeforeAggregateContext.new(@child_collection, caller, filter, aggregation, limit)
+          @hooks['Aggregate'].execute_before(before_context)
+
+          results = @child_collection.aggregate(
+            caller,
+            before_context.filter,
+            before_context.aggregation,
+            before_context.limit
+          )
+
+          after_context = After::HookAfterAggregateContext.new(
+            @child_collection,
+            caller,
+            filter,
+            aggregation,
+            results,
+            limit
+          )
+          @hooks['Aggregate'].execute_after(after_context)
+
+          results
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/hook/hooks.rb

@@ -0,0 +1,26 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Hook
+      class Hooks
+        attr_reader :before, :after
+
+        def initialize
+          @before = []
+          @after = []
+        end
+
+        def execute_before(context)
+          @before.each { |hook| hook.call(context) }
+        end
+
+        def execute_after(context)
+          @after.each { |hook| hook.call(context) }
+        end
+
+        def add_handler(position, hook)
+          position == 'After' ? @after << hook : @before << hook
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/operators_emulate/operators_emulate_collection_decorator.rb

@@ -0,0 +1,118 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module OperatorsEmulate
+      class OperatorsEmulateCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit
+        include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        attr_accessor :fields
+
+        def initialize(child_collection, datasource)
+          super
+          @fields = {}
+        end
+
+        def emulate_field_operator(name, operator)
+          replace_field_operator(name, operator)
+        end
+
+        def replace_field_operator(name, operator, &replace_by)
+          # Check that the collection can actually support our rewriting
+          pks = Utils::Schema.primary_keys(child_collection)
+          pks.each do |pk|
+            schema = child_collection.schema[:fields][pk]
+            operators = schema.filter_operators
+
+            if !operators.include?(Operators::EQUAL) || !operators.include?(Operators::IN)
+              raise Exceptions::ForestException, "Cannot override operators on collection #{self.name}: " \
+                                                 "the primary key columns must support 'Equal' and 'In' operators."
+            end
+          end
+
+          # Check that targeted field is valid
+          field = child_collection.schema[:fields][name]
+          Validations::FieldValidator.validate(self, name)
+          unless field.is_a?(ForestAdminDatasourceToolkit::Schema::ColumnSchema)
+            raise Exceptions::ForestException, 'Cannot replace operator for relation'
+          end
+
+          # Mark the field operator as replaced.
+          fields[name] = {} unless fields.key?(name)
+          fields[name][operator] = replace_by
+          mark_schema_as_dirty
+        end
+
+        protected
+
+        def refine_schema(sub_schema)
+          sub_schema[:fields].map do |name, schema|
+            schema.filter_operators = schema.filter_operators.union(fields[name].keys) if fields.key?(name)
+
+            schema
+          end
+
+          sub_schema
+        end
+
+        def refine_filter(caller, filter = nil)
+          filter&.override(
+            condition_tree: filter.condition_tree&.replace_leafs do |leaf|
+              replace_leaf(caller, leaf, [])
+            end
+          )
+        end
+
+        def replace_leaf(caller, leaf, replacements)
+          # ConditionTree is targeting a field on another collection => recurse.
+          if leaf.field.include?(':')
+            prefix = leaf.field.split(':').first
+            relation_schema = schema[:fields][prefix]
+            association = datasource.get_collection(relation_schema.foreign_collection)
+            association_leaf = leaf.unnest.replace_leafs do |sub_leaf|
+              association.replace_leaf(caller, sub_leaf, replacements)
+            end
+
+            return association_leaf.nest(prefix)
+          end
+
+          fields[leaf.field]&.key?(leaf.operator) ? compute_equivalent(caller, leaf, replacements) : leaf
+        end
+
+        def compute_equivalent(caller, leaf, replacements)
+          handler = fields.dig(leaf.field, leaf.operator)
+          if handler
+            replacement_id = "#{name}.#{leaf.field}[#{leaf.operator}]"
+            sub_replacements = replacements.union([replacement_id])
+            if replacements.include?(replacement_id)
+              raise Exceptions::ForestException, "Operator replacement cycle: #{sub_replacements.join(" -> ")}"
+            end
+
+            result = handler.call(leaf.value, Context::CollectionCustomizationContext.new(self, caller))
+
+            if result
+              equivalent = result.class < Nodes::ConditionTree ? result : ConditionTreeFactory.from_plain_object(result)
+              equivalent.replace_leafs do |sub_leaf|
+                replace_leaf(caller, sub_leaf, sub_replacements)
+              end
+
+              Validations::ConditionTreeValidator.validate(equivalent, self)
+
+              return equivalent
+            end
+          end
+
+          ConditionTreeFactory.match_records(
+            self,
+            leaf.apply(
+              list(caller, Filter.new, leaf.projection.with_pks(self)),
+              self,
+              caller.timezone
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/operators_equivalence/operators_equivalence_collection_decorator.rb

@@ -0,0 +1,50 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module OperatorsEquivalence
+      class OperatorsEquivalenceCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        protected
+
+        def refine_schema(sub_schema)
+          schema = sub_schema.dup
+          schema[:fields] = sub_schema[:fields].dup
+
+          schema[:fields].map do |_name, field_schema|
+            if field_schema.type == 'Column'
+              new_operators = Operators.all.select do |operator|
+                ConditionTreeEquivalent.equivalent_tree?(operator, field_schema.filter_operators,
+                                                         field_schema.column_type)
+              end
+
+              field_schema.filter_operators = new_operators
+            else
+              field_schema
+            end
+          end
+
+          schema
+        end
+
+        def refine_filter(caller, filter = nil)
+          filter&.override(
+            condition_tree: filter.condition_tree&.replace_leafs do |leaf|
+              schema = ForestAdminDatasourceToolkit::Utils::Collection.get_field_schema(
+                @child_collection,
+                leaf.field
+              )
+
+              ConditionTreeEquivalent.get_equivalent_tree(
+                leaf,
+                schema.filter_operators,
+                schema.column_type,
+                caller.timezone
+              )
+            end
+          )
+        end
+      end
+    end
+  end
+end