forest_admin_datasource_customizer 1.0.0.pre.beta.86 → 1.0.0.pre.beta.88

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98b615fe1c829b8a99d8c2dac3bb852c09a669ae328ff353746c55f6f61c152f
-  data.tar.gz: ea82667001dfcd0e5e37b39feebce3a7a368188eaf55235312dd5a48bc92e6a1
+  metadata.gz: 8c7120cf1ef2b8e044dfe6e93646c75be81f8b8e9fd28b4e1c157f03db1d705a
+  data.tar.gz: 99c70deb71c742d033bae93fcebcd028dfbece9d4eae804e51d62b40da16ecbd
 SHA512:
-  metadata.gz: be6a34cd0435042dab88b00b583ff2ef064e01562391fd10f4bbbf5799b4fe478593fbb9efdc0e248879fbbe87e34c7e21ad2ed7bfca2becc4be28e8de3647fe
-  data.tar.gz: 9e16a66fb986e7be63cf7be72969f2e79ac565cdc752e0123585a19ede2401a0346dbd523d3cbbf630597cf6feb4a401a677f563592797e6e016869b5c5e5a4b
+  metadata.gz: 3cdc27aba86bf2925c5db8cb0be2b105702352fbbb9a7a1b1fd91193189d250f819a097397eae438ec92d6dceba388ab622d441f84a353c99d90acdb88a6dfd3
+  data.tar.gz: 4e747e188ed52a3403bbea8a74fb01e086e32ac283436178535bce196c52e6e682a2fad589dc167f2d54f2d80b7d3d324281547a91afbac2f907432ae74f1d4f

data/lib/forest_admin_datasource_customizer/collection_customizer.rb

@@ -33,6 +33,13 @@ module ForestAdminDatasourceCustomizer
       push_customization { @stack.search.get_collection(@name).replace_search(definition) }
     end
 
+    # Disable the search bar
+    # Example:
+    #   collection.disable_search
+    def disable_search
+      push_customization { @stack.search.get_collection(@name).disable_search }
+    end
+
     def add_field(name, definition)
       push_customization do
         collection_before_relations = @stack.early_computed.get_collection(@name)

data/lib/forest_admin_datasource_customizer/decorators/decorators_stack.rb

@@ -5,7 +5,7 @@ module ForestAdminDatasourceCustomizer
 
       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
+                  :binary, :override, :lazy_join
 
       def initialize(datasource)
         @customizations = []
@@ -19,6 +19,8 @@ module ForestAdminDatasourceCustomizer
         last = @early_op_emulate = DatasourceDecorator.new(last, OperatorsEmulate::OperatorsEmulateCollectionDecorator)
         last = DatasourceDecorator.new(last, OperatorsEquivalence::OperatorsEquivalenceCollectionDecorator)
         last = @relation = DatasourceDecorator.new(last, Relation::RelationCollectionDecorator)
+        # lazy join is just before relation, to avoid relations to do useless stuff
+        last = @lazy_join = DatasourceDecorator.new(last, LazyJoin::LazyJoinCollectionDecorator)
         last = @late_computed = DatasourceDecorator.new(last, Computed::ComputeCollectionDecorator)
         last = @late_op_emulate = DatasourceDecorator.new(last, OperatorsEmulate::OperatorsEmulateCollectionDecorator)
         last = DatasourceDecorator.new(last, OperatorsEquivalence::OperatorsEquivalenceCollectionDecorator)

data/lib/forest_admin_datasource_customizer/decorators/lazy_join/lazy_join_collection_decorator.rb

@@ -0,0 +1,129 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module LazyJoin
+      class LazyJoinCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        def list(caller, filter, projection)
+          simplified_projection = get_projection_without_useless_joins(projection)
+          refined_filter = refine_filter(caller, filter)
+          records = child_collection.list(caller, refined_filter, simplified_projection)
+
+          apply_joins_on_records(projection, simplified_projection, records)
+        end
+
+        def aggregate(caller, filter, aggregation, limit = nil)
+          refined_filter = refine_filter(caller, filter)
+          replaced = {}
+          refined_aggregation = aggregation.replace_fields do |field_name|
+            if useless_join?(field_name.split(':')[0], aggregation.projection)
+              new_field_name = get_foreign_key_for_projection(field_name)
+              replaced[new_field_name] = field_name
+
+              new_field_name
+            else
+              field_name
+            end
+          end
+
+          results = child_collection.aggregate(caller, refined_filter, refined_aggregation, limit)
+
+          apply_joins_on_aggregate_result(aggregation, refined_aggregation, results, replaced)
+        end
+
+        def refine_filter(_caller, filter = nil)
+          filter&.override(
+            condition_tree: filter.condition_tree&.replace_leafs do |leaf|
+              if useless_join?(leaf.field.split(':')[0], filter.condition_tree.projection)
+                leaf.override(field: get_foreign_key_for_projection(leaf.field))
+              else
+                leaf
+              end
+            end
+          )
+        end
+
+        private
+
+        def get_foreign_key_for_projection(field_name)
+          relation_name = field_name.split(':')[0]
+          relation_schema = schema[:fields][relation_name]
+
+          relation_schema.foreign_key
+        end
+
+        def useless_join?(relation_name, projection)
+          relation_schema = schema[:fields][relation_name]
+          sub_projection = projection.relations[relation_name]
+
+          relation_schema.type == 'ManyToOne' &&
+            sub_projection.size == 1 &&
+            sub_projection[0] == relation_schema.foreign_key_target
+        end
+
+        def get_projection_without_useless_joins(projection)
+          new_projection = Projection.new(projection)
+
+          projection.relations.each do |relation_name, relation_projection|
+            next unless useless_join?(relation_name, projection)
+
+            # remove foreign key target from projection
+            new_projection.delete("#{relation_name}:#{relation_projection[0]}")
+
+            # add foreign keys to projection
+            fk_field = get_foreign_key_for_projection("#{relation_name}:#{relation_projection[0]}")
+            new_projection << fk_field
+          end
+
+          new_projection
+        end
+
+        def apply_joins_on_records(initial_projection, requested_projection, records)
+          return records if initial_projection == requested_projection
+
+          projections_to_add = Projection.new(initial_projection.reject do |field|
+            requested_projection.include?(field)
+          end)
+          projections_to_rm = Projection.new(requested_projection.reject { |field| initial_projection.include?(field) })
+
+          records.each do |record|
+            # add to record relation:id
+            projections_to_add.relations.each do |relation_name, relation_projection|
+              relation_schema = schema[:fields][relation_name]
+
+              if relation_schema && relation_schema.type == 'ManyToOne'
+                fk_value = record[get_foreign_key_for_projection("#{relation_name}:#{relation_projection[0]}")]
+                record[relation_name] = fk_value.nil? ? nil : { relation_projection[0] => fk_value }
+              end
+            end
+
+            # remove foreign keys
+            projections_to_rm.each { |field| record.delete(field) }
+          end
+
+          records
+        end
+
+        def apply_joins_on_aggregate_result(initial_aggregation, requested_aggregation, results, fields_to_replace)
+          return result if initial_aggregation == requested_aggregation
+
+          results.each do |result|
+            group = {}
+            result['group'].each do |field, value|
+              if fields_to_replace.include?(field)
+                group[fields_to_replace[field]] = value
+              else
+                group[field] = value
+              end
+            end
+            result['group'] = group
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/search/search_collection_decorator.rb

@@ -8,6 +8,11 @@ module ForestAdminDatasourceCustomizer
         def initialize(child_collection, datasource)
           super
           @replacer = nil
+          @disabled_search = get_fields(false).empty?
+        end
+
+        def disable_search
+          @disabled_search = true
         end
 
         def replace_search(replacer)
@@ -15,7 +20,7 @@ module ForestAdminDatasourceCustomizer
         end
 
         def refine_schema(sub_schema)
-          sub_schema.merge({ searchable: true })
+          sub_schema.merge({ searchable: !@disabled_search })
         end
 
         def refine_filter(caller, filter)
@@ -48,7 +53,7 @@ module ForestAdminDatasourceCustomizer
         private
 
         def default_replacer(search, extended)
-          searchable_fields = get_fields(@child_collection, extended)
+          searchable_fields = get_fields(extended)
 
           conditions = searchable_fields.map do |field, schema|
             build_condition(field, schema, search)
@@ -64,11 +69,11 @@ module ForestAdminDatasourceCustomizer
           is_number = number?(search_string)
           is_uuid = uuid?(search_string)
 
-          if column_type == PrimitiveType::NUMBER && is_number && filter_operators&.include?(Operators::EQUAL)
+          if column_type == PrimitiveType::NUMBER && is_number
             return Nodes::ConditionTreeLeaf.new(field, Operators::EQUAL, search_string.to_f)
           end
 
-          if column_type == PrimitiveType::ENUM && filter_operators&.include?(Operators::EQUAL)
+          if column_type == PrimitiveType::ENUM
             search_value = lenient_find(enum_values, search_string)
 
             return Nodes::ConditionTreeLeaf.new(field, Operators::EQUAL, search_value) if search_value
@@ -92,17 +97,17 @@ module ForestAdminDatasourceCustomizer
             return Nodes::ConditionTreeLeaf.new(field, operator, search_string) if operator
           end
 
-          if column_type == PrimitiveType::UUID && is_uuid && filter_operators&.include?(Operators::EQUAL)
+          if column_type == PrimitiveType::UUID && is_uuid
             return Nodes::ConditionTreeLeaf.new(field, Operators::EQUAL, search_string)
           end
 
           nil
         end
 
-        def get_fields(collection, extended)
+        def get_fields(extended)
           fields = []
-          collection.schema[:fields].each do |name, field|
-            fields.push([name, field]) if field.type == 'Column'
+          @child_collection.schema[:fields].each do |name, field|
+            fields.push([name, field]) if field.type == 'Column' && searchable_field?(field)
 
             if field.type == 'PolymorphicManyToOne' && extended
               ForestAdminAgent::Facades::Container.logger.log(
@@ -116,16 +121,30 @@ module ForestAdminDatasourceCustomizer
             next unless extended &&
                         (field.type == 'ManyToOne' || field.type == 'OneToOne' || field.type == 'PolymorphicOneToOne')
 
-            related = collection.datasource.get_collection(field.foreign_collection)
+            related = @child_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'
+              fields.push(["#{name}:#{sub_name}", sub_field]) if sub_field.type == 'Column' &&
+                                                                 searchable_field?(sub_field)
             end
           end
 
           fields
         end
 
+        def searchable_field?(field)
+          operators = field.filter_operators
+
+          if field.column_type == PrimitiveType::STRING
+            return operators&.include?(Operators::EQUAL) ||
+                   operators&.include?(Operators::CONTAINS) ||
+                   operators&.include?(Operators::I_CONTAINS)
+          end
+
+          [PrimitiveType::UUID, PrimitiveType::ENUM, PrimitiveType::NUMBER].include?(field.column_type) &&
+            operators&.include?(Operators::EQUAL)
+        end
+
         def lenient_find(haystack, needle)
           haystack&.find { |v| v == needle.strip } || haystack&.find { |v| v.downcase == needle.downcase.strip }
         end

data/lib/forest_admin_datasource_customizer/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceCustomizer
-  VERSION = "1.0.0-beta.86"
+  VERSION = "1.0.0-beta.88"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_customizer
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.86
+  version: 1.0.0.pre.beta.88
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-01-06 00:00:00.000000000 Z
+date: 2025-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -116,6 +116,7 @@ files:
 - lib/forest_admin_datasource_customizer/decorators/hook/context/hook_context.rb
 - lib/forest_admin_datasource_customizer/decorators/hook/hook_collection_decorator.rb
 - lib/forest_admin_datasource_customizer/decorators/hook/hooks.rb
+- lib/forest_admin_datasource_customizer/decorators/lazy_join/lazy_join_collection_decorator.rb
 - lib/forest_admin_datasource_customizer/decorators/operators_emulate/operators_emulate_collection_decorator.rb
 - lib/forest_admin_datasource_customizer/decorators/operators_equivalence/operators_equivalence_collection_decorator.rb
 - lib/forest_admin_datasource_customizer/decorators/override/context/create_override_customization_context.rb