forest_admin_datasource_active_record 1.0.0.pre.beta.60 → 1.0.0.pre.beta.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06eb4e50d70ed020e78c247129d24f1a514efcc8e3150864ac00e2a420d715ed
-  data.tar.gz: e11b2afab09fbf5ac3e9555a288f70638e2c01e5d2135a983b8601324d701916
+  metadata.gz: 768aba915cd8fc48929a8bdc08fdf81dd735aa9b6d8d7f2a7f2ecb4c99c4e854
+  data.tar.gz: 32a0e8e3b7468dd6ec2244ea1b59da6383af8f36f48b4c5d7025094550612eca
 SHA512:
-  metadata.gz: 895ce913914b2400d39f09b197ef29e25524bcd524e75749a206cb5be6797665f026eac1ab0f99bceff4b11d9546c56edd3e92155c90a68434705faba6b411ec
-  data.tar.gz: 5afa4e3d45800cce7d9f1a274eba8ccaf78d5c473460e1ccc56dada1064319d7e5d4b1a81b53ccadf293a64f61a1d607021665c6fdee7d95f1f143af4051d29f
+  metadata.gz: 7cea2e22bccfce7e48423cce3656b9457cea8882721bb6f39dc6ca44b7edc8fefcb9f0b8bde0226f33fa3ae5dcaae0b5d23113eeb92e6ef9e71793d70c427fb1
+  data.tar.gz: 7a015c989b6183d4a97c8d95f1f614b7a6fa58d64e2a498072e246218e6398040e22ec7098bc260ee8cc045119adf8155a64063cad007ad5f0c8ee93869979e6

data/lib/forest_admin_datasource_active_record/collection.rb

@@ -6,9 +6,10 @@ module ForestAdminDatasourceActiveRecord
 
     attr_reader :model
 
-    def initialize(datasource, model)
+    def initialize(datasource, model, support_polymorphic_relations: false)
       @model = model
-      name = model.name.demodulize.underscore
+      @support_polymorphic_relations = support_polymorphic_relations
+      name = format_model_name(@model.name)
       super(datasource, name)
       fetch_fields
       fetch_associations
@@ -30,12 +31,12 @@ module ForestAdminDatasourceActiveRecord
     end
 
     def create(_caller, data)
-      Utils::ActiveRecordSerializer.new(@model.create(data)).to_hash
+      Utils::ActiveRecordSerializer.new(@model.create(data)).to_hash(ProjectionFactory.all(self))
     end
 
     def update(_caller, filter, data)
       entity = Utils::Query.new(self, nil, filter).build.first
-      entity.update(data)
+      entity&.update(data)
     end
 
     def delete(_caller, filter)
@@ -45,6 +46,10 @@ module ForestAdminDatasourceActiveRecord
 
     private
 
+    def format_model_name(class_name)
+      class_name.gsub('::', '__')
+    end
+
     def fetch_fields
       @model.columns_hash.each do |column_name, column|
         field = ForestAdminDatasourceToolkit::Schema::ColumnSchema.new(
@@ -63,49 +68,112 @@ module ForestAdminDatasourceActiveRecord
       end
     end
 
+    def association_primary_key?(association)
+      !association.association_primary_key.empty?
+    rescue StandardError
+      association.polymorphic?
+    end
+
     def fetch_associations
-      associations(@model).each do |association|
+      associations(@model, support_polymorphic_relations: @support_polymorphic_relations).each do |association|
         case association.macro
         when :has_one
-          add_field(
-            association.name.to_s,
-            ForestAdminDatasourceToolkit::Schema::Relations::OneToOneSchema.new(
-              foreign_collection: association.class_name.demodulize.underscore,
-              origin_key: association.foreign_key,
-              origin_key_target: association.association_primary_key
-            )
-          )
+          if association_primary_key?(association)
+            if association.through_reflection?
+              add_field(
+                association.name.to_s,
+                ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema.new(
+                  foreign_collection: format_model_name(association.klass.name),
+                  origin_key: association.through_reflection.foreign_key,
+                  origin_key_target: association.through_reflection.join_foreign_key,
+                  foreign_key: association.join_foreign_key,
+                  foreign_key_target: association.association_primary_key,
+                  through_collection: format_model_name(association.through_reflection.klass.name)
+                )
+              )
+            elsif association.inverse_of.polymorphic?
+              add_field(
+                association.name.to_s,
+                ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicOneToOneSchema.new(
+                  foreign_collection: format_model_name(association.klass.name),
+                  origin_key: association.foreign_key,
+                  origin_key_target: association.association_primary_key,
+                  origin_type_field: association.inverse_of.foreign_type,
+                  origin_type_value: @model.name
+                )
+              )
+            else
+              add_field(
+                association.name.to_s,
+                ForestAdminDatasourceToolkit::Schema::Relations::OneToOneSchema.new(
+                  foreign_collection: format_model_name(association.klass.name),
+                  origin_key: association.foreign_key,
+                  origin_key_target: association.association_primary_key
+                )
+              )
+            end
+          end
         when :belongs_to
-          add_field(
-            association.name.to_s,
-            ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema.new(
-              foreign_collection: association.class_name.demodulize.underscore,
-              foreign_key: association.foreign_key,
-              foreign_key_target: association.association_primary_key
-            )
-          )
+          if association_primary_key?(association)
+            if polymorphic?(association)
+              foreign_collections = get_polymorphic_types(association)
+              add_field(
+                association.name.to_s,
+                ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicManyToOneSchema.new(
+                  foreign_collections: foreign_collections.keys,
+                  foreign_key: association.foreign_key,
+                  foreign_key_type_field: association.foreign_type,
+                  foreign_key_targets: foreign_collections
+                )
+              )
+              schema[:fields][association.foreign_key].is_read_only = true
+              schema[:fields][association.foreign_type].is_read_only = true
+            else
+              add_field(
+                association.name.to_s,
+                ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema.new(
+                  foreign_collection: format_model_name(association.klass.name),
+                  foreign_key: association.foreign_key,
+                  foreign_key_target: association.association_primary_key
+                )
+              )
+            end
+          end
         when :has_many
-          if association.through_reflection?
-            add_field(
-              association.name.to_s,
-              ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema.new(
-                foreign_collection: association.class_name.demodulize.underscore,
-                origin_key: association.through_reflection.foreign_key,
-                origin_key_target: association.through_reflection.join_foreign_key,
-                foreign_key: association.join_foreign_key,
-                foreign_key_target: association.association_primary_key,
-                through_collection: association.through_reflection.class_name.demodulize.underscore
+          if association_primary_key?(association)
+            if association.through_reflection?
+              add_field(
+                association.name.to_s,
+                ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema.new(
+                  foreign_collection: format_model_name(association.klass.name),
+                  origin_key: association.through_reflection.foreign_key,
+                  origin_key_target: association.through_reflection.join_foreign_key,
+                  foreign_key: association.join_foreign_key,
+                  foreign_key_target: association.association_primary_key,
+                  through_collection: format_model_name(association.through_reflection.klass.name)
+                )
+              )
+            elsif association.inverse_of.polymorphic?
+              add_field(
+                association.name.to_s,
+                ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicOneToManySchema.new(
+                  foreign_collection: format_model_name(association.klass.name),
+                  origin_key: association.foreign_key,
+                  origin_key_target: association.association_primary_key,
+                  origin_type_field: association.inverse_of.foreign_type,
+                  origin_type_value: @model.name
+                )
               )
-            )
-          else
-            add_field(
-              association.name.to_s,
-              ForestAdminDatasourceToolkit::Schema::Relations::OneToManySchema.new(
-                foreign_collection: association.class_name.demodulize.underscore,
-                origin_key: association.foreign_key,
-                origin_key_target: association.association_primary_key
+            else
+              add_field(
+                association.name.to_s,
+                ForestAdminDatasourceToolkit::Schema::Relations::OneToManySchema.new(
+                  foreign_collection: format_model_name(association.klass.name),
+                  origin_key: association.foreign_key,
+                  origin_key_target: association.association_primary_key
+                )
               )
-            )
+            end
           end
         end
       end

data/lib/forest_admin_datasource_active_record/datasource.rb

@@ -2,9 +2,12 @@ require 'active_record'
 
 module ForestAdminDatasourceActiveRecord
   class Datasource < ForestAdminDatasourceToolkit::Datasource
-    def initialize(db_config = {})
+    attr_reader :models
+
+    def initialize(db_config = {}, support_polymorphic_relations: false)
       super()
       @models = []
+      @support_polymorphic_relations = support_polymorphic_relations
       @habtm_models = {}
       init_orm(db_config)
       generate
@@ -15,15 +18,26 @@ module ForestAdminDatasourceActiveRecord
     def generate
       ActiveRecord::Base.descendants.each { |model| fetch_model(model) }
       @models.each do |model|
-        add_collection(Collection.new(self, model))
+        add_collection(
+          Collection.new(self, model, support_polymorphic_relations: @support_polymorphic_relations)
+        )
       end
     end
 
+    def primary_key?(model)
+      !model.primary_key.empty?
+    rescue StandardError
+      false
+    end
+
     def fetch_model(model)
       if model.name.start_with?('HABTM_')
         build_habtm(model)
       else
-        @models << model unless model.abstract_class? || @models.include?(model) || !model.table_exists?
+        @models << model unless model.abstract_class? ||
+                                @models.include?(model) ||
+                                !model.table_exists? ||
+                                !primary_key?(model)
       end
     end
 

data/lib/forest_admin_datasource_active_record/parser/relation.rb

@@ -1,14 +1,19 @@
 module ForestAdminDatasourceActiveRecord
   module Parser
     module Relation
-      def associations(model)
+      def associations(model, support_polymorphic_relations: false)
         model.reflect_on_all_associations.select do |association|
-          !polymorphic?(association) && !active_type?(association.klass)
+          if support_polymorphic_relations
+            polymorphic?(association) ? true : !active_type?(association.klass)
+          else
+            !polymorphic?(association) && !active_type?(association.klass)
+          end
         end
       end
 
       def polymorphic?(association)
-        association.options[:polymorphic]
+        (association.options.key?(:polymorphic) && association.options[:polymorphic]) ||
+          association.inverse_of&.polymorphic?
       end
 
       # NOTICE: Ignores ActiveType::Object association during introspection and interactions.
@@ -16,6 +21,17 @@ module ForestAdminDatasourceActiveRecord
       def active_type?(model)
         Object.const_defined?('ActiveType::Object') && model < ActiveType::Object
       end
+
+      def get_polymorphic_types(relation)
+        types = {}
+        @datasource.models.each do |model|
+          unless model.reflect_on_all_associations.none? { |assoc| assoc.options[:as] == relation.name.to_sym }
+            types[format_model_name(model.name)] = model.primary_key
+          end
+        end
+
+        types
+      end
     end
   end
 end

data/lib/forest_admin_datasource_active_record/utils/active_record_serializer.rb

@@ -13,7 +13,7 @@ module ForestAdminDatasourceActiveRecord
         hash.merge! object.attributes
 
         if with_associations
-          each_association_collection(object) do |association_name, item|
+          each_association_collection(object, projection) do |association_name, item|
             hash[association_name] = hash_object(
               item,
               projection.relations[association_name],
@@ -25,9 +25,10 @@ module ForestAdminDatasourceActiveRecord
         hash
       end
 
-      def each_association_collection(object)
+      def each_association_collection(object, projection)
         one_associations = %i[has_one belongs_to]
-        object.class.reflect_on_all_associations.filter { |a| one_associations.include?(a.macro) }
+        object.class.reflect_on_all_associations
+              .filter { |a| one_associations.include?(a.macro) && projection.relations.key?(a.name.to_s) }
               .each { |association| yield(association.name.to_s, object.send(association.name.to_s)) }
       end
     end

data/lib/forest_admin_datasource_active_record/utils/query.rb

@@ -123,14 +123,11 @@ module ForestAdminDatasourceActiveRecord
       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_name)
-          @select << "#{table_name}.#{field}"
 
           return "#{table_name}.#{field}"
         end

data/lib/forest_admin_datasource_active_record/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceActiveRecord
-  VERSION = "1.0.0-beta.60"
+  VERSION = "1.0.0-beta.62"
 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.60
+  version: 1.0.0.pre.beta.62
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-08 00:00:00.000000000 Z
+date: 2024-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord