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

data/lib/forest_admin_datasource_customizer/decorators/override/context/create_override_customization_context.rb

@@ -0,0 +1,16 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Override
+      module Context
+        class CreateOverrideCustomizationContext < ForestAdminDatasourceCustomizer::Context::CollectionCustomizationContext
+          attr_reader :data
+
+          def initialize(collection, caller, data)
+            super(collection, caller)
+            @data = data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/override/context/delete_override_customization_context.rb

@@ -0,0 +1,16 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Override
+      module Context
+        class DeleteOverrideCustomizationContext < ForestAdminDatasourceCustomizer::Context::CollectionCustomizationContext
+          attr_reader :filter
+
+          def initialize(collection, caller, filter)
+            super(collection, caller)
+            @filter = filter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/override/context/update_override_customization_context.rb

@@ -0,0 +1,17 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Override
+      module Context
+        class UpdateOverrideCustomizationContext < ForestAdminDatasourceCustomizer::Context::CollectionCustomizationContext
+          attr_reader :filter, :patch
+
+          def initialize(collection, caller, filter, patch)
+            super(collection, caller)
+            @filter = filter
+            @patch = patch
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/override/override_collection_decorator.rb

@@ -0,0 +1,49 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Override
+      class OverrideCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include Context
+        attr_reader :create_handler, :update_handler, :delete_handler
+
+        def create(caller, data)
+          if @create_handler
+            context = CreateOverrideCustomizationContext.new(@child_collection, caller, data)
+            return @create_handler.call(context)
+          end
+
+          super
+        end
+
+        def add_create_handler(handler)
+          @create_handler = handler
+        end
+
+        def update(caller, filter, patch)
+          if @update_handler
+            context = UpdateOverrideCustomizationContext.new(@child_collection, caller, filter, patch)
+            return @update_handler.call(context)
+          end
+
+          super
+        end
+
+        def add_update_handler(handler)
+          @update_handler = handler
+        end
+
+        def delete(caller, filter)
+          if @delete_handler
+            context = DeleteOverrideCustomizationContext.new(@child_collection, caller, filter)
+            return @delete_handler.call(context)
+          end
+
+          super
+        end
+
+        def add_delete_handler(handler)
+          @delete_handler = handler
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/publication/publication_collection_decorator.rb

@@ -0,0 +1,95 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Publication
+      class PublicationCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Exceptions
+        attr_reader :blacklist
+
+        def initialize(child_collection, datasource)
+          super
+          @blacklist = []
+        end
+
+        def change_field_visibility(name, visible)
+          field = child_collection.schema[:fields][name]
+          raise ForestException, "No such field '#{name}'" unless field
+          raise ForestException, 'Cannot hide primary key' if ForestAdminDatasourceToolkit::Utils::Schema.primary_key?(
+            child_collection, name
+          )
+
+          if visible
+            @blacklist.delete(name)
+          else
+            @blacklist << name
+          end
+
+          mark_schema_as_dirty
+        end
+
+        def create(caller, data)
+          record = {}
+          child_collection.create(caller, data).each do |key, value|
+            record[key] = value unless @blacklist.include?(key)
+          end
+
+          record
+        end
+
+        def refine_schema(child_schema)
+          fields = {}
+
+          child_schema[:fields].each do |name, field|
+            fields[name] = field if published?(name)
+          end
+
+          child_schema[:fields] = fields
+
+          child_schema
+        end
+
+        def published?(name)
+          # Explicitly hidden
+          return false if @blacklist.include?(name)
+
+          # Implicitly hidden
+          field = child_collection.schema[:fields][name]
+
+          if field.type == 'ManyToOne'
+            return (
+              datasource.published?(field.foreign_collection) &&
+              published?(field.foreign_key) &&
+              datasource.get_collection(field.foreign_collection).published?(field.foreign_key_target)
+            )
+          end
+
+          if field.type == 'OneToOne' || field.type == 'OneToMany'
+            return (
+              datasource.published?(field.foreign_collection) &&
+              datasource.get_collection(field.foreign_collection).published?(field.origin_key) &&
+              published?(field.origin_key_target)
+            )
+          end
+
+          if field.type == 'ManyToMany'
+            return (
+              datasource.published?(field.through_collection) &&
+              datasource.published?(field.foreign_collection) &&
+              datasource.get_collection(field.through_collection).published?(field.foreign_key) &&
+              datasource.get_collection(field.through_collection).published?(field.origin_key) &&
+              published?(field.origin_key_target) &&
+              datasource.get_collection(field.foreign_collection).published?(field.foreign_key_target)
+            )
+          end
+
+          true
+        end
+
+        # rubocop:disable Lint/UselessMethodDefinition
+        def mark_schema_as_dirty
+          super
+        end
+        # rubocop:enable Lint/UselessMethodDefinition
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/publication/publication_datasource_decorator.rb

@@ -0,0 +1,57 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Publication
+      class PublicationDatasourceDecorator < ForestAdminDatasourceToolkit::Decorators::DatasourceDecorator
+        include ForestAdminDatasourceToolkit::Exceptions
+        attr_reader :blacklist
+
+        def initialize(child_datasource)
+          super(child_datasource, PublicationCollectionDecorator)
+          @blacklist = []
+        end
+
+        def collections
+          @child_datasource.collections.except(*@blacklist).to_h do |name, _collection|
+            [name, get_collection(name)]
+          end
+        end
+
+        def get_collection(name)
+          raise ForestException, "Collection '#{name}' was removed." if @blacklist.include?(name)
+
+          super
+        end
+
+        def keep_collections_matching(include = [], exclude = [])
+          validate_collection_names(include.to_a + exclude.to_a)
+
+          # List collection we're keeping from the white/black list.
+          @child_datasource.collections.each_key do |collection|
+            remove_collection(collection) if (include && !include.include?(collection)) || exclude&.include?(collection)
+          end
+        end
+
+        def remove_collection(collection_name)
+          validate_collection_names([collection_name])
+
+          # Delete the collection
+          @blacklist << collection_name
+
+          # Tell all collections that their schema is dirty: if we removed a collection, all
+          # relations to this collection are now invalid and should be unpublished.
+          collections.each_value(&:mark_schema_as_dirty)
+        end
+
+        def published?(collection_name)
+          !@blacklist.include?(collection_name)
+        end
+
+        private
+
+        def validate_collection_names(names)
+          names.each { |name| get_collection(name) }
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/relation/relation_collection_decorator.rb

@@ -0,0 +1,268 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Relation
+      class RelationCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Exceptions
+        include ForestAdminDatasourceToolkit::Utils
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes
+        include ForestAdminDatasourceToolkit::Schema
+
+        attr_reader :relations
+
+        def initialize(child_collection, datasource)
+          super
+          @relations = {}
+        end
+
+        def add_relation(name, partial_joint)
+          relation = relation_with_optional_fields(partial_joint)
+          check_foreign_keys(relation)
+          check_origin_keys(relation)
+
+          @relations[name] = relation
+          mark_schema_as_dirty
+        end
+
+        def list(caller, filter, projection)
+          new_filter = refine_filter(caller, filter)
+          new_projection = projection.replace { |field| rewrite_field(field) }
+          records = child_collection.list(caller, new_filter, new_projection)
+          return records if new_projection.equals(projection)
+
+          records = re_project_in_place(caller, records, projection)
+
+          projection.apply(records)
+        end
+
+        def aggregate(caller, filter, aggregation, limit = nil)
+          new_filter = refine_filter(caller, filter)
+
+          # No emulated relations are used in the aggregation
+          if aggregation.projection.relations.keys.all? { |prefix| !@relations.key?(prefix) }
+            return child_collection.aggregate(caller, new_filter, aggregation, limit)
+          end
+
+          # Fallback to full emulation.
+          aggregation.apply(list(caller, filter, aggregation.projection), caller.timezone, limit)
+        end
+
+        protected
+
+        def refine_schema(child_schema)
+          @relations.each do |name, relation|
+            child_schema[:fields][name] = relation
+          end
+
+          child_schema
+        end
+
+        def refine_filter(caller, filter)
+          filter.override({
+                            condition_tree: filter.condition_tree&.replace_leafs do |leaf|
+                                              rewrite_leaf(caller, leaf)
+                                            end,
+                            sort: filter.sort&.replace_clauses do |clause|
+                              rewrite_field(clause[:field]).map do |field|
+                                clause.merge(field: field)
+                              end
+                            end
+                          })
+        end
+
+        def relation_with_optional_fields(partial_joint)
+          relation = partial_joint.dup
+          target = datasource.get_collection(partial_joint[:foreign_collection])
+
+          case relation[:type]
+          when 'ManyToOne'
+            relation = Relations::ManyToOneSchema.new(
+              foreign_key: relation[:foreign_key],
+              foreign_key_target: if relation[:foreign_key_target].nil?
+                                    ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(target).first
+                                  else
+                                    relation[:foreign_key_target]
+                                  end,
+              foreign_collection: relation[:foreign_collection]
+            )
+          when 'OneToOne'
+            relation = Relations::OneToOneSchema.new(
+              origin_key: relation[:origin_key],
+              origin_key_target: if relation[:origin_key_target].nil?
+                                   ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(self).first
+                                 else
+                                   relation[:origin_key_target]
+                                 end,
+              foreign_collection: relation[:foreign_collection]
+            )
+          when 'OneToMany'
+            relation = Relations::OneToManySchema.new(
+              origin_key: relation[:origin_key],
+              origin_key_target: if relation[:origin_key_target].nil?
+                                   ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(self).first
+                                 else
+                                   relation[:origin_key_target]
+                                 end,
+              foreign_collection: relation[:foreign_collection]
+            )
+          when 'ManyToMany'
+            relation = Relations::ManyToManySchema.new(
+              origin_key: relation[:origin_key],
+              origin_key_target: if relation[:origin_key_target].nil?
+                                   ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(self).first
+                                 else
+                                   relation[:origin_key_target]
+                                 end,
+              foreign_key: relation[:foreign_key],
+              foreign_key_target: if relation[:foreign_key_target].nil?
+                                    ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(target).first
+                                  else
+                                    relation[:foreign_key_target]
+                                  end,
+              foreign_collection: relation[:foreign_collection],
+              through_collection: relation[:through_collection]
+            )
+          end
+
+          relation
+        end
+
+        def check_foreign_keys(relation)
+          return unless relation.type == 'ManyToOne' || relation.type == 'ManyToMany'
+
+          check_keys(
+            relation.type == 'ManyToMany' ? datasource.get_collection(relation.through_collection) : self,
+            datasource.get_collection(relation.foreign_collection),
+            relation.foreign_key,
+            relation.foreign_key_target
+          )
+        end
+
+        def check_origin_keys(relation)
+          return unless relation.type == 'OneToMany' || relation.type == 'OneToOne' || relation.type == 'ManyToMany'
+
+          check_keys(
+            relation.type == 'ManyToMany' ? datasource.get_collection(relation.through_collection) : datasource.get_collection(relation.foreign_collection),
+            self,
+            relation.origin_key,
+            relation.origin_key_target
+          )
+        end
+
+        def check_keys(owner, target_owner, key_name, target_name)
+          check_column(owner, key_name)
+          check_column(target_owner, target_name)
+
+          key = owner.schema[:fields][key_name]
+          target = target_owner.schema[:fields][target_name]
+
+          return unless key.column_type != target.column_type
+
+          raise ForestException,
+                "Types from '#{owner.name}.#{key_name}' and '#{target_owner.name}.#{target_name}' do not match."
+        end
+
+        def check_column(owner, name)
+          column = owner.schema[:fields][name]
+
+          raise ForestException, "Column not found: '#{owner.name}.#{name}'" if !column || column.type != 'Column'
+
+          return if column.filter_operators.include?(Operators::IN)
+
+          raise ForestException, "Column does not support the In operator: '#{owner.name}.#{name}'"
+        end
+
+        def rewrite_field(field)
+          prefix = field.split(':').first
+          field_schema = schema[:fields][prefix]
+
+          return [field] if field_schema.type == 'Column'
+
+          relation = datasource.get_collection(field_schema.foreign_collection)
+          result = []
+
+          if !@relations.key?(prefix)
+            result = relation.rewrite_field(field[prefix.length + 1..]).map { |sub_field| "#{prefix}:#{sub_field}" }
+          elsif field_schema.is_a? Relations::ManyToOneSchema
+            result = [field_schema.foreign_key]
+          elsif field_schema.is_a?(Relations::OneToOneSchema) ||
+                field_schema.is_a?(Relations::OneToManySchema) ||
+                field_schema.is_a?(Relations::ManyToManySchema)
+            result = [field_schema.origin_key_target]
+          end
+
+          result
+        end
+
+        def rewrite_leaf(caller, leaf)
+          prefix = leaf.field.split(':').first
+          field_schema = schema[:fields][prefix]
+          return leaf if field_schema.type == 'Column'
+
+          relation = datasource.get_collection(field_schema.foreign_collection)
+          result = leaf
+
+          if !@relations.key?(prefix)
+            result = relation.rewrite_leaf(caller, leaf.unnest).nest(prefix)
+          elsif field_schema.type == 'ManyToOne'
+            records = relation.list(
+              caller,
+              Filter.new(condition_tree: leaf.unnest),
+              Projection.new([field_schema.foreign_key_target])
+            )
+
+            result = ConditionTreeLeaf.new(field_schema.foreign_key, 'In', records.map do |record|
+                                                                             record[field_schema.foreign_key_target]
+                                                                           end.uniq)
+          elsif field_schema.type == 'OneToOne'
+            records = relation.list(
+              caller,
+              Filter.new(condition_tree: leaf.unnest),
+              Projection.new([field_schema.origin_key])
+            )
+
+            result = ConditionTreeLeaf.new(field_schema.origin_key_target, 'In', records.map do |record|
+                                                                                   record[field_schema.origin_key]
+                                                                                 end.uniq)
+          end
+
+          result
+        end
+
+        def re_project_in_place(caller, records, projection)
+          projection.relations.each do |prefix, sub_projection|
+            re_project_relation_in_place(caller, records, prefix, sub_projection)
+          end
+
+          records
+        end
+
+        def re_project_relation_in_place(caller, records, name, projection)
+          field_schema = schema[:fields][name]
+          association = datasource.get_collection(field_schema.foreign_collection)
+
+          if !@relations[name]
+            association.re_project_in_place(caller, records.map { |r| r[name] }.filter { |fk| !fk.nil? }, projection)
+          elsif field_schema.type == 'ManyToOne'
+            ids = records.map { |record| record[field_schema.foreign_key] }.filter { |fk| !fk.nil? }.uniq
+            sub_filter = Filter.new(condition_tree: ConditionTreeLeaf.new(field_schema.foreign_key_target, 'In', ids))
+            sub_records = association.list(caller, sub_filter, projection.union([field_schema.foreign_key_target]))
+
+            records.each do |record|
+              record[name] = sub_records.find { |sr| sr[field_schema.foreign_key_target] == record[field_schema.foreign_key] }
+            end
+          elsif field_schema.type == 'OneToOne' || field_schema.type == 'OneToMany'
+            ids = records.map { |record| record[field_schema.origin_key_target] }.filter { |okt| !okt.nil? }.uniq
+            sub_filter = Filter.new(condition_tree: ConditionTreeLeaf.new(field_schema.origin_key, 'In', ids))
+            sub_records = association.list(caller, sub_filter, projection.union([field_schema.origin_key]))
+
+            records.each do |record|
+              record[name] = sub_records.find { |sr| sr[field_schema.origin_key] == record[field_schema.origin_key_target] }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/rename_collection/rename_collection_datasource_decorator.rb

@@ -0,0 +1,70 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module RenameCollection
+      class RenameCollectionDatasourceDecorator < ForestAdminDatasourceToolkit::Decorators::DatasourceDecorator
+        include ForestAdminDatasourceToolkit
+        include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        def initialize(child_datasource)
+          @from_child_name = {}
+          @to_child_name = {}
+          super(child_datasource, RenameCollectionDecorator)
+        end
+
+        def collections
+          @child_datasource.collections.to_h do |name, _collection|
+            [name, method(:get_collection).super_method.call(name)]
+          end
+        end
+
+        def get_collection(name)
+          # Collection has been renamed, user is using the new name
+          return super(@to_child_name[name]) if @to_child_name.key?(name)
+
+          # Collection has been renamed, user is using the old name
+          if @from_child_name.key?(name)
+            raise Exceptions::ForestException, "Collection '#{name}' has been renamed to '#{@from_child_name[name]}'"
+          end
+
+          # Collection has not been renamed
+          super
+        end
+
+        def rename_collections(renames = [])
+          renames.each do |current_name, new_name|
+            rename_collection(current_name, new_name)
+          end
+        end
+
+        def rename_collection(current_name, new_name)
+          # Check collection exists
+          get_collection(current_name)
+
+          return unless current_name != new_name
+
+          # Check new name is not already used
+          if collections.any? { |name, _collection| name == new_name }
+            raise Exceptions::ForestException,
+                  "The given new collection name '#{new_name}' is already defined"
+          end
+
+          # Check we don't rename a collection twice
+          if @to_child_name[current_name]
+            raise Exceptions::ForestException,
+                  "Cannot rename a collection twice: #{@to_child_name[current_name]}->#{current_name}->#{new_name}"
+          end
+
+          @from_child_name[current_name] = new_name
+          @to_child_name[new_name] = current_name
+
+          collections.each_value(&:mark_schema_as_dirty)
+        end
+
+        def get_collection_name(child_name)
+          @from_child_name[child_name] || child_name
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/rename_collection/rename_collection_decorator.rb

@@ -0,0 +1,37 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module RenameCollection
+      class RenameCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        def name
+          datasource.get_collection_name(super)
+        end
+
+        def refine_schema(sub_schema)
+          fields = {}
+
+          sub_schema[:fields].each do |name, old_schema|
+            if old_schema.type != 'Column'
+              old_schema.foreign_collection = datasource.get_collection_name(old_schema.foreign_collection)
+              if old_schema.type == 'ManyToMany'
+                old_schema.through_collection = datasource.get_collection_name(old_schema.through_collection)
+              end
+            end
+
+            fields[name] = old_schema
+          end
+
+          sub_schema
+        end
+
+        # rubocop:disable Lint/UselessMethodDefinition
+        def mark_schema_as_dirty
+          super
+        end
+        # rubocop:enable Lint/UselessMethodDefinition
+      end
+    end
+  end
+end