forest_admin_datasource_active_record 1.0.0.pre.beta.53 → 1.0.0.pre.beta.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 241691e966a9bd75b1cf66d07cc640e8ad2201fef29640568fafca6490c28250
-  data.tar.gz: 4db07ffe9fa5d0c0f9397c9b4b7073850440aa5a68d8329ef1e350d2e23ba7db
+  metadata.gz: 24b6a78fb3119d0686735b3d7d550148fad3d6a8c6a0251867230f13cc0c043f
+  data.tar.gz: 2912d1b2435e29fd19a3284debaa7ba97bdcd1bd223af8629645b9630a915656
 SHA512:
-  metadata.gz: d7b4af902acab6b8edd4067603f6de7f1e3420608a78b44a5ee339125030b54e4508a50f4956c50bad891a8d77c92f6854d922fd5e3debfbe9cf6706555fcacf
-  data.tar.gz: 817416e1dc2c846b473f1afec82f922205560c8802f8b340507337714aa4388bc1d328436ad2b5bfaae24cef2b52960da69d6c25e7cb5c4b991a17bfd1e52d3c
+  metadata.gz: ec1c79b449b3855576a9a318b50094fff0cb126a8a421718175b68bb76bf83939badc2a3c68625f3c723a53e0051d7f8d36621bfd5f618b6f7307e49a7553aba
+  data.tar.gz: d059a3bb21bc5b66a5bfceeb13f6e3b12abe5690a5cb9f6dfe26c80c5acdcbd4d53cf97476e69ac260a1762851a2d23a04d0dcfbeb8fe70a2d754c228f891e37

data/lib/forest_admin_datasource_active_record/collection.rb

@@ -47,11 +47,10 @@ module ForestAdminDatasourceActiveRecord
 
     def fetch_fields
       @model.columns_hash.each do |column_name, column|
-        # TODO: check is not sti column
         field = ForestAdminDatasourceToolkit::Schema::ColumnSchema.new(
           column_type: get_column_type(@model, column),
           filter_operators: operators_for_column_type(get_column_type(@model, column)),
-          is_primary_key: column_name == @model.primary_key,
+          is_primary_key: column_name == @model.primary_key || @model.primary_key.include?(column_name),
           is_read_only: false,
           is_sortable: true,
           default_value: column.default,

data/lib/forest_admin_datasource_active_record/datasource.rb

@@ -5,6 +5,7 @@ module ForestAdminDatasourceActiveRecord
     def initialize(db_config = {})
       super()
       @models = []
+      @habtm_models = {}
       init_orm(db_config)
       generate
     end
@@ -19,11 +20,52 @@ module ForestAdminDatasourceActiveRecord
     end
 
     def fetch_model(model)
-      @models << model unless model.abstract_class? || @models.include?(model) || !model.table_exists?
+      if model.name.start_with?('HABTM_')
+        build_habtm(model)
+      else
+        @models << model unless model.abstract_class? || @models.include?(model) || !model.table_exists?
+      end
     end
 
     def init_orm(db_config)
       ActiveRecord::Base.establish_connection(db_config)
     end
+
+    def build_habtm(model)
+      if @habtm_models.key?(model.table_name)
+        @habtm_models[model.table_name].left_reflection = model.right_reflection
+        # when the second model is added, we can push the HABTM model to the models list
+        @models << make_through_model(
+          model.table_name,
+          [
+            @habtm_models[model.table_name].left_reflection,
+            @habtm_models[model.table_name].right_reflection
+          ]
+        )
+      else
+        @habtm_models[model.table_name] = model
+      end
+    end
+
+    def make_through_model(table_name, associations)
+      through_model = Class.new(ActiveRecord::Base) do
+        class << self
+          attr_accessor :name, :table_name
+        end
+
+        def self.add_association(name, options)
+          belongs_to name, required: false, **options
+        end
+      end
+
+      through_model.name = table_name.singularize
+      through_model.table_name = table_name
+      through_model.primary_key = [associations[0].foreign_key, associations[1].foreign_key]
+      associations.each do |association|
+        through_model.add_association(association.name, association.options)
+      end
+
+      through_model
+    end
   end
 end

data/lib/forest_admin_datasource_active_record/utils/query.rb

@@ -50,39 +50,41 @@ module ForestAdminDatasourceActiveRecord
 
       def apply_condition_tree(condition_tree, aggregator = nil)
         if condition_tree.is_a? Nodes::ConditionTreeBranch
-          aggregator = condition_tree.aggregator.downcase
+          aggregator = condition_tree.aggregator.downcase.to_sym
           condition_tree.conditions.each do |condition|
-            query = apply_condition_tree(condition, aggregator)
-            @query = @query.send(aggregator, query)
+            @query = apply_condition_tree(condition, aggregator)
+            @query = @query.send(aggregator, @query)
           end
 
           @query
         else
-          compute_main_operator(condition_tree, aggregator || 'and')
+          @query = compute_main_operator(condition_tree, aggregator || :and)
         end
       end
 
       def compute_main_operator(condition_tree, aggregator)
         field = format_field(condition_tree.field)
         value = condition_tree.value
+        aggregator = aggregator.to_sym
 
         case condition_tree.operator
         when Operators::PRESENT
-          @query = @query.send(aggregator, @query.where.not({ field => nil }))
+          @query = query_aggregator(aggregator, @collection.model.where.not({ field => nil }))
         when Operators::EQUAL, Operators::IN
-          @query = @query.send(aggregator, @query.where({ field => value }))
+          @query = query_aggregator(aggregator, @collection.model.where({ field => value }))
         when Operators::NOT_EQUAL, Operators::NOT_IN
-          @query = @query.send(aggregator, @query.where.not({ field => value }))
+          @query = query_aggregator(aggregator, @collection.model.where.not({ field => value }))
         when Operators::GREATER_THAN
-          @query = @query.send(aggregator, @query.where(@arel_table[field.to_sym].gt(value)))
+          @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].gt(value)))
         when Operators::LESS_THAN
-          @query = @query.send(aggregator, @query.where(@arel_table[field.to_sym].lt(value)))
+          @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].lt(value)))
         when Operators::NOT_CONTAINS
-          @query = @query.send(aggregator, @query.where.not(@arel_table[field.to_sym].matches("%#{value}%")))
+          @query = query_aggregator(aggregator,
+                                    @collection.model.where.not(@arel_table[field.to_sym].matches("%#{value}%")))
         when Operators::LIKE
-          @query = @query.send(aggregator, @query.where(@arel_table[field.to_sym].matches(value)))
+          @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].matches(value)))
         when Operators::INCLUDES_ALL
-          @query = @query.send(aggregator, @query.where(@arel_table[field.to_sym].matches_all(value)))
+          @query = query_aggregator(aggregator, @collection.model.where(@arel_table[field.to_sym].matches_all(value)))
         end
 
         @query
@@ -93,7 +95,7 @@ module ForestAdminDatasourceActiveRecord
           @select += @projection.columns.map { |field| "#{@collection.model.table_name}.#{field}" }
           @projection.relations.each_key do |relation|
             relation_schema = @collection.schema[:fields][relation]
-            @select << if relation_schema.type == 'OneToOne'
+            @select << if relation_schema.type == 'OneToOne' || relation_schema.type == 'PolymorphicOneToOne'
                          "#{@collection.model.table_name}.#{relation_schema.origin_key_target}"
                        else
                          "#{@collection.model.table_name}.#{relation_schema.foreign_key}"
@@ -107,35 +109,41 @@ module ForestAdminDatasourceActiveRecord
       def apply_select
         unless @projection.nil?
           @query = @query.select(@select.join(', '))
-          @query = @query.eager_load(@projection.relations.keys.map(&:to_sym))
-          # TODO: replace eager_load by joins because eager_load select ALL columns of relation
-          # @query = @query.joins(@projection.relations.keys.map(&:to_sym))
+          @query = @query.includes(@projection.relations.keys.map(&:to_sym))
         end
 
         @query
       end
 
-      def add_join_relation(relation, relation_name)
-        if relation.type == 'ManyToMany'
-          # TODO: to implement
-        else
-          @query = @query.joins(relation_name.to_sym)
-        end
+      def add_join_relation(relation_name)
+        @query = @query.includes(relation_name.to_sym)
 
         @query
       end
 
       def format_field(field)
+        @select << "#{@collection.model.table_name}.#{field}"
+
         if field.include?(':')
           relation_name, field = field.split(':')
           relation = @collection.schema[:fields][relation_name]
           table_name = @collection.datasource.get_collection(relation.foreign_collection).model.table_name
-          add_join_relation(relation, relation_name)
+          add_join_relation(relation_name)
+          @select << "#{table_name}.#{field}"
+
           return "#{table_name}.#{field}"
         end
 
         field
       end
+
+      def query_aggregator(aggregator, query)
+        if !@query.respond_to?(:where_clause) || @query.where_clause.empty?
+          query
+        else
+          @query.send(aggregator, query)
+        end
+      end
     end
   end
 end

data/lib/forest_admin_datasource_active_record/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceActiveRecord
-  VERSION = "1.0.0-beta.53"
+  VERSION = "1.0.0-beta.55"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_active_record
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.53
+  version: 1.0.0.pre.beta.55
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-10 00:00:00.000000000 Z
+date: 2024-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord