forest_liana 8.0.16 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d66f322c9f51d6beebaa2eb338b8f568f7d12bc781d71c4b47a8c2c3e6503c73
-  data.tar.gz: 37db17c392bac96b35c43595c03ef702e840ae40e420538151d36edc2a347c68
+  metadata.gz: e051d1446dd0f16749a9d078bb0caee6ff1b93c37557b5fdc0571fca710137f8
+  data.tar.gz: 90db1924c8d20ef02b3525eb84bba26ed03025fe042b4c6405d83ebaf3ac2e23
 SHA512:
-  metadata.gz: 9466f6b82dc0ffbfae007bfc0024e5b831172dacdffcf00e51c58a8ca2333dbbefb165227a3d36b704954b1cdb75ecdfb9a5f2605840572220e612226e6cb39d
-  data.tar.gz: 5c313811aead7c0617d1e5d5d9c424f66e56b0482a46dc8354a1714b59f61490a728cc1cacb9224553110b0577b68712ba62366e8b214d6c7bddb2daffde4c7d
+  metadata.gz: 87d40012a5f767ebc6faf75c5cb9826d50afc536837daad7f578f85ecf8b6e4c82f20d2c4eb246a4a3197e7e8d0ef6ad294362dccd5100b1194ce3897fda8044
+  data.tar.gz: 3d24e8527ae65ec0945ebd309a4958257ee4b12792d78f41e72427baea073333f4630756dc48254fef347ad467976a5bddeddf85d823432c94f34a4f8e465eb5

data/app/deserializers/forest_liana/resource_deserializer.rb

@@ -63,7 +63,12 @@ module ForestLiana
             # ActionController::Parameters do not inherit from Hash anymore
             # since Rails 5.
             if (data.is_a?(Hash) || data.is_a?(ActionController::Parameters)) && data[:id]
-              @attributes[name] = association.klass.find(data[:id])
+              if (SchemaUtils.polymorphic?(association))
+                @attributes[association.foreign_key] = data[:id]
+                @attributes[association.foreign_type] = data[:type]
+              else
+                @attributes[name] = association.klass.find(data[:id])
+              end
             elsif data.blank?
               @attributes[name] = nil
             end

data/app/helpers/forest_liana/query_helper.rb

@@ -1,8 +1,16 @@
 module ForestLiana
   module QueryHelper
     def self.get_one_associations(resource)
-      SchemaUtils.one_associations(resource)
-        .select { |association| SchemaUtils.model_included?(association.klass) }
+      associations = SchemaUtils.one_associations(resource)
+        .select do |association|
+          if SchemaUtils.polymorphic?(association)
+            SchemaUtils.polymorphic_models(association).all? { |model| SchemaUtils.model_included?(model) }
+          else
+            SchemaUtils.model_included?(association.klass)
+          end
+        end
+
+      associations
     end
 
     def self.get_one_association_names_symbol(resource)
@@ -18,10 +26,19 @@ module ForestLiana
       associations_has_one = self.get_one_associations(resource)
 
       associations_has_one.each do |association|
-        if tables_associated_to_relations_name[association.table_name].nil?
-          tables_associated_to_relations_name[association.table_name] = []
+        if SchemaUtils.polymorphic?(association)
+          SchemaUtils.polymorphic_models(association).each do |model|
+            if tables_associated_to_relations_name[model.table_name].nil?
+              tables_associated_to_relations_name[model.table_name] = []
+            end
+            tables_associated_to_relations_name[model.table_name] << association.name
+          end
+        else
+          if tables_associated_to_relations_name[association.try(:table_name)].nil?
+            tables_associated_to_relations_name[association.table_name] = []
+          end
+          tables_associated_to_relations_name[association.table_name] << association.name
         end
-        tables_associated_to_relations_name[association.table_name] << association.name
       end
 
       tables_associated_to_relations_name

data/app/serializers/forest_liana/serializer_factory.rb

@@ -265,7 +265,19 @@ module ForestLiana
 
         SchemaUtils.associations(active_record_class).each do |a|
           begin
-            if SchemaUtils.model_included?(a.klass)
+            if SchemaUtils.polymorphic?(a)
+              serializer.send(serializer_association(a), a.name) {
+                if [:has_one, :belongs_to].include?(a.macro)
+                  begin
+                    object.send(a.name)
+                  rescue ActiveRecord::RecordNotFound
+                    nil
+                  end
+                else
+                  []
+                end
+              }
+            elsif SchemaUtils.model_included?(a.klass)
               serializer.send(serializer_association(a), a.name) {
                 if [:has_one, :belongs_to].include?(a.macro)
                   begin
@@ -369,6 +381,7 @@ module ForestLiana
 
     def attributes(active_record_class)
       return [] if @is_smart_collection
+
       active_record_class.column_names.select do |column_name|
         !association?(active_record_class, column_name)
       end
@@ -410,6 +423,9 @@ module ForestLiana
     def foreign_keys(active_record_class)
       begin
         SchemaUtils.belongs_to_associations(active_record_class).map(&:foreign_key)
+        SchemaUtils.belongs_to_associations(active_record_class)
+                   .select { |association| !SchemaUtils.polymorphic?(association) }
+                   .map(&:foreign_key)
       rescue => err
         # Association foreign_key triggers an error. Put the stacktrace and
         # returns no foreign keys.

data/app/services/forest_liana/apimap_sorter.rb

@@ -29,6 +29,7 @@ module ForestLiana
       'relationship',
       'widget',
       'validations',
+      'polymorphic_referenced_models',
     ]
     KEYS_ACTION = [
       'name',

data/app/services/forest_liana/base_getter.rb

@@ -33,16 +33,23 @@ module ForestLiana
     def optimize_record_loading(resource, records)
       instance_dependent_associations = instance_dependent_associations(resource)
 
+      polymorphic = []
       preload_loads = @includes.select do |name|
-        targetModelConnection = resource.reflect_on_association(name).klass.connection
-        targetModelDatabase = targetModelConnection.current_database if targetModelConnection.respond_to? :current_database
-        resourceConnection = resource.connection
-        resourceDatabase = resourceConnection.current_database if resourceConnection.respond_to? :current_database
+        association = resource.reflect_on_association(name)
+        if SchemaUtils.polymorphic?(association)
+          polymorphic << association.name
+          false
+        else
+          targetModelConnection = association.klass.connection
+          targetModelDatabase = targetModelConnection.current_database if targetModelConnection.respond_to? :current_database
+          resourceConnection = resource.connection
+          resourceDatabase = resourceConnection.current_database if resourceConnection.respond_to? :current_database
 
-        targetModelDatabase != resourceDatabase
+          targetModelDatabase != resourceDatabase
+        end
       end + instance_dependent_associations
 
-      result = records.eager_load(@includes - preload_loads)
+      result = records.eager_load(@includes - preload_loads - polymorphic)
 
       # Rails 7 can mix `eager_load` and `preload` in the same scope
       # Rails 6 cannot mix `eager_load` and `preload` in the same scope

data/app/services/forest_liana/belongs_to_updater.rb

@@ -13,7 +13,16 @@ module ForestLiana
     def perform
       begin
         @record = @resource.find(@params[:id])
-        new_value = @association.klass.find(@data[:id]) if @data && @data[:id]
+        if (SchemaUtils.polymorphic?(@association))
+          if @data.nil?
+            new_value = nil
+          else
+            association_klass = SchemaUtils.polymorphic_models(@association).select { |a| a.name.downcase == @data[:type] }.first
+            new_value = association_klass.find(@data[:id]) if @data && @data[:id]
+          end
+        else
+          new_value = @association.klass.find(@data[:id]) if @data && @data[:id]
+        end
         @record.send("#{@association.name}=", new_value)
 
         @record.save

data/app/services/forest_liana/has_many_getter.rb

@@ -40,17 +40,23 @@ module ForestLiana
       @includes = @association.klass
         .reflect_on_all_associations
         .select do |association|
-          inclusion = !association.options[:polymorphic] &&
-            SchemaUtils.model_included?(association.klass) &&
-            [:belongs_to, :has_and_belongs_to_many].include?(association.macro)
 
-          if @field_names_requested
-            inclusion && @field_names_requested.include?(association.name)
+          if SchemaUtils.polymorphic?(association)
+            inclusion = SchemaUtils.polymorphic_models(association)
+                                   .all? { |model| SchemaUtils.model_included?(model) } &&
+              [:belongs_to, :has_and_belongs_to_many].include?(association.macro)
           else
-            inclusion
+            inclusion = SchemaUtils.model_included?(association.klass) &&
+              [:belongs_to, :has_and_belongs_to_many].include?(association.macro)
           end
-        end
-        .map { |association| association.name.to_s }
+
+            if @field_names_requested
+              inclusion && @field_names_requested.include?(association.name)
+            else
+              inclusion
+            end
+          end
+        .map { |association| association.name }
     end
 
     def field_names_requested

data/app/services/forest_liana/schema_adapter.rb

@@ -241,8 +241,33 @@ module ForestLiana
     def add_associations
       SchemaUtils.associations(@model).each do |association|
         begin
+          if SchemaUtils.polymorphic?(association) &&
+            (ENV['ENABLE_SUPPORT_POLYMORPHISM'].present? && ENV['ENABLE_SUPPORT_POLYMORPHISM'].downcase == 'true')
+            
+            collection.fields << {
+              field: association.name.to_s,
+              type: get_type_for_association(association),
+              relationship: get_relationship_type(association),
+              reference: "#{association.name.to_s}.id",
+              inverse_of: @model.name.demodulize.underscore,
+              is_filterable: false,
+              is_sortable: true,
+              is_read_only: false,
+              is_required: false,
+              is_virtual: false,
+              default_value: nil,
+              integration: nil,
+              relationships: nil,
+              widget: nil,
+              validations: [],
+              polymorphic_referenced_models: get_polymorphic_types(association)
+            }
+
+            collection.fields = collection.fields.reject do |field|
+              field[:field] == association.foreign_key || field[:field] == association.foreign_type
+            end
           # NOTICE: Delete the association if the targeted model is excluded.
-          if !SchemaUtils.model_included?(association.klass)
+          elsif !SchemaUtils.model_included?(association.klass)
             field = collection.fields.find do |x|
               x[:field] == association.foreign_key
             end
@@ -275,6 +300,17 @@ module ForestLiana
         automatic_inverse_of(association)
     end
 
+    def get_polymorphic_types(relation)
+      types = []
+      ForestLiana.models.each do |model|
+        unless model.reflect_on_all_associations.select { |association| association.options[:as] == relation.name.to_sym }.empty?
+          types << model.name
+        end
+      end
+
+      types
+    end
+
     def automatic_inverse_of(association)
       name = association.active_record.name.demodulize.underscore
 

data/app/services/forest_liana/schema_utils.rb

@@ -4,7 +4,12 @@ module ForestLiana
     def self.associations(active_record_class)
       active_record_class.reflect_on_all_associations.select do |association|
         begin
-          !polymorphic?(association) && !is_active_type?(association.klass)
+          if (ENV['ENABLE_SUPPORT_POLYMORPHISM'].present? && ENV['ENABLE_SUPPORT_POLYMORPHISM'].downcase == 'true')
+            polymorphic?(association) ? true : !is_active_type?(association.klass)
+          else
+            !polymorphic?(association) && !is_active_type?(association.klass)
+          end
+
         rescue
           FOREST_LOGGER.warn "Unknown association #{association.name} on class #{active_record_class.name}"
           false
@@ -53,12 +58,30 @@ module ForestLiana
       ActiveRecord::Base.connection.tables
     end
 
-    private
-
     def self.polymorphic?(association)
       association.options[:polymorphic]
     end
 
+    def self.klass(association)
+      return association.klass unless polymorphic?(association)
+
+
+    end
+
+    def self.polymorphic_models(relation)
+      models = []
+      ForestLiana.models.each do |model|
+        unless model.reflect_on_all_associations.select { |association| association.options[:as] == relation.name.to_sym }.empty?
+          models << model
+        end
+      end
+
+      models
+    end
+
+
+    private
+
     def self.find_model_from_abstract_class(abstract_class, collection_name)
       abstract_class.subclasses.find do |subclass|
         if subclass.abstract_class?

data/app/services/forest_liana/stat_getter.rb

@@ -6,9 +6,17 @@ module ForestLiana
       @resource = resource
       @params = params
       @user = forest_user
+
+      validate_params
       compute_includes
     end
 
+    def validate_params
+      if @params.key?(:aggregator) && !%w[count sum avg max min].include?(@params[:aggregator].downcase)
+        raise ForestLiana::Errors::HTTP422Error.new('Invalid aggregate function')
+      end
+    end
+
     def get_resource
       super
       @resource.reorder('')

data/app/services/forest_liana/value_stat_getter.rb

@@ -19,24 +19,25 @@ module ForestLiana
       end
 
       @record = Model::Stat.new(value: {
-        countCurrent: count(resource),
-        countPrevious: previous_value ? count(previous_value) : nil
+        countCurrent: aggregate(resource),
+        countPrevious: previous_value ? aggregate(previous_value) : nil
       })
     end
 
     private
 
-    def count(value)
-      uniq = @params[:aggregator].downcase == 'count'
+    def aggregate(value)
+      aggregator = @params[:aggregator].downcase
+      uniq = aggregator == 'count'
 
       if Rails::VERSION::MAJOR >= 4
         if uniq
           # NOTICE: uniq is deprecated since Rails 5.0
           value = Rails::VERSION::MAJOR >= 5 ? value.distinct : value.uniq
         end
-        value.send(@params[:aggregator].downcase, aggregate_field)
+        value.send(aggregator, aggregate_field)
       else
-        value.send(@params[:aggregator].downcase, aggregate_field, distinct: uniq)
+        value.send(aggregator, aggregate_field, distinct: uniq)
       end
     end
 

data/lib/forest_liana/bootstrapper.rb

@@ -5,7 +5,12 @@ module ForestLiana
   class Bootstrapper
     SCHEMA_FILENAME = File.join(Dir.pwd, '.forestadmin-schema.json')
 
-    def initialize
+    def initialize(reset_api_map = false)
+      if reset_api_map
+        ForestLiana.apimap = []
+        ForestLiana.models = []
+      end
+
       @integration_stripe_valid = false
       @integration_intercom_valid = false
 

data/lib/forest_liana/schema_file_updater.rb

@@ -35,6 +35,7 @@ module ForestLiana
       'relationship',
       'widget',
       'validations',
+      'polymorphic_referenced_models',
     ]
     KEYS_VALIDATION = [
       'message',

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "8.0.16"
+  VERSION = "8.1.0"
 end

data/lib/tasks/send_apimap.rake

@@ -3,7 +3,7 @@ namespace :forest do
   task(:send_apimap).clear
   task send_apimap: :environment do
     if ForestLiana.env_secret
-      bootstrapper = ForestLiana::Bootstrapper.new
+      bootstrapper = ForestLiana::Bootstrapper.new(true)
       bootstrapper.synchronize(true)
     else
       puts 'Cannot send the Apimap, Forest cannot find your env_secret'

data/spec/dummy/app/models/address.rb

@@ -0,0 +1,5 @@
+class Address < ActiveRecord::Base
+  self.table_name = 'addresses'
+
+  belongs_to :addressable, polymorphic: true
+end

data/spec/dummy/app/models/user.rb

@@ -1,6 +1,7 @@
 class User < ActiveRecord::Base
   has_many :trees_owned, class_name: 'Tree', inverse_of: :owner
   has_many :trees_cut, class_name: 'Tree', inverse_of: :cutter
+  has_many :addresses, as: :addressable
 
   enum title: [ :king, :villager, :outlaw ]
 end

data/spec/dummy/db/migrate/20231117084236_create_addresses.rb

@@ -0,0 +1,12 @@
+class CreateAddresses < ActiveRecord::Migration[6.0]
+  def change
+    create_table :addresses do |t|
+      t.string :line1
+      t.string :city
+      t.string :zipcode
+      t.references :addressable, polymorphic: true, null: false
+
+      t.timestamps
+    end
+  end
+end

data/spec/dummy/db/schema.rb

@@ -10,7 +10,18 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 2022_07_27_114930) do
+ActiveRecord::Schema.define(version: 2023_11_17_084236) do
+
+  create_table "addresses", force: :cascade do |t|
+    t.string "line1"
+    t.string "city"
+    t.string "zipcode"
+    t.string "addressable_type", null: false
+    t.integer "addressable_id", null: false
+    t.datetime "created_at", precision: 6, null: false
+    t.datetime "updated_at", precision: 6, null: false
+    t.index ["addressable_type", "addressable_id"], name: "index_addresses_on_addressable_type_and_addressable_id"
+  end
 
   create_table "isle", force: :cascade do |t|
     t.string "name"

data/spec/helpers/forest_liana/query_helper_spec.rb

@@ -3,6 +3,7 @@ module ForestLiana
     before(:all) do
       Tree.connection
       User.connection
+      Address.connection
       Island.connection
     end
 
@@ -14,6 +15,21 @@ module ForestLiana
         end
       end
 
+      context 'on a model having 1 polymorphic association' do
+        it 'should return the association' do
+          associations = QueryHelper.get_one_associations(Address)
+          expect(associations).to eq(Address.reflect_on_all_associations(:belongs_to))
+        end
+
+        it 'should return 0 association when one of referenced model was excluded' do
+          allow(ForestLiana).to receive(:excluded_models).and_return(['User'])
+          associations = QueryHelper.get_one_associations(Address)
+
+          expect(associations.length).to eq(0)
+        end
+      end
+
+
       context 'on a model having some belongsTo associations' do
         let(:expected_association_attributes) do
           [
@@ -75,7 +91,15 @@ module ForestLiana
           expect(tables_associated_to_relations_name['isle'].second).to eq(:eponymous_island)
         end
       end
-    end
 
+      context 'on a model having polymorphic association' do
+        tables_associated_to_relations_name =
+          QueryHelper.get_tables_associated_to_relations_name(Address)
+
+        it 'should return the one-one associations' do
+          expect(tables_associated_to_relations_name.keys.length).to eq(1)
+        end
+      end
+    end
   end
 end

data/spec/lib/forest_liana/bootstrapper_spec.rb

@@ -23,6 +23,7 @@ module ForestLiana
 
       let(:expected_application_models) do
         [
+          Address,
           Island,
           Location,
           Manufacturer,

data/spec/lib/forest_liana/schema_file_updater_spec.rb

@@ -10,6 +10,41 @@ module ForestLiana
       end
 
       describe "with a given collection" do
+        describe "when the collection has a polymorphic relation" do
+          it "should save the relation" do
+            collections = [
+              {
+                "name" => "Address",
+                "fields" => [
+                  {
+                    "field" => "addressable",
+                    "type" => "Number",
+                    "relationship" => "BelongsTo",
+                    "reference" => "addressable.id",
+                    "inverse_of" => "address",
+                    "is_filterable" => false,
+                    "is_sortable" => true,
+                    "is_read_only" => false,
+                    "is_required" => false,
+                    "is_virtual" => false,
+                    "default_value" => nil,
+                    "integration" => nil,
+                    "relationships" => nil,
+                    "widget" => nil,
+                    "validations" => [],
+                    "polymorphic_referenced_models" => ["User"]
+                  },
+                ],
+                "actions" => [],
+                "segments" => []
+              }
+            ]
+            schema_file_updater = ForestLiana::SchemaFileUpdater.new("test.txt", collections, {})
+            expect(schema_file_updater.instance_variable_get(:@collections))
+              .to eq(collections)
+          end
+        end
+
         describe "when the collection has a smart action action" do
           it "should save the smart action" do
             collections = [{

data/spec/requests/resources_spec.rb

@@ -154,3 +154,87 @@ describe 'Requesting Tree resources', :type => :request  do
     end
   end
 end
+
+describe 'Requesting Address resources', :type => :request  do
+
+  before do
+    user = User.create(name: 'Michel')
+    address = Address.create(line1: '10 Downing Street', city: 'London', zipcode: '2AB', addressable: user)
+
+    Rails.cache.write('forest.users', {'1' => { 'id' => 1, 'roleId' => 1, 'rendering_id' => '1' }})
+    Rails.cache.write('forest.has_permission', true)
+    Rails.cache.write(
+      'forest.collections',
+      {
+        'Address' => {
+          'browse'  => [1],
+          'read'    => [1],
+          'edit'    => [1],
+          'add'     => [1],
+          'delete'  => [1],
+          'export'  => [1],
+          'actions' => {}
+        }
+      }
+    )
+
+    allow(ForestLiana::IpWhitelist).to receive(:retrieve) { true }
+    allow(ForestLiana::IpWhitelist).to receive(:is_ip_whitelist_retrieved) { true }
+    allow(ForestLiana::IpWhitelist).to receive(:is_ip_valid) { true }
+    allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return({})
+  end
+
+  after do
+    User.destroy_all
+    Address.destroy_all
+  end
+
+  token = JWT.encode({
+    id: 1,
+    email: 'michael.kelso@that70.show',
+    first_name: 'Michael',
+    last_name: 'Kelso',
+    team: 'Operations',
+    rendering_id: 16,
+    exp: Time.now.to_i + 2.weeks.to_i,
+    permission_level: 'admin'
+  }, ForestLiana.auth_secret, 'HS256')
+
+  headers = {
+    'Accept' => 'application/json',
+    'Content-Type' => 'application/json',
+    'Authorization' => "Bearer #{token}"
+  }
+
+  describe 'index' do
+    params = {
+      fields: { 'Address' => 'id,line1,city,zip_code,addressable' },
+      page: { 'number' => '1', 'size' => '10' },
+      searchExtended: '0',
+      sort: '-id',
+      timezone: 'Europe/Paris'
+    }
+
+    it 'should respond the address data' do
+      get '/forest/Address', params: params, headers: headers
+
+      expect(JSON.parse(response.body)).to include(
+        "data" => [
+          {
+            "type" => "Address",
+            "id" => "1",
+            "attributes" => {
+              "id" => 1,
+              "line1" => "10 Downing Street",
+              "city" => "London"
+            },
+            "links" => { "self" => "/forest/address/1" },
+            "relationships" => {
+              "addressable" => { "links" => { "related" => {} }, "data" => { "type" => "User", "id" => "1" } }
+            }
+          }
+        ]
+      )
+    end
+  end
+end

data/spec/services/forest_liana/line_stat_getter_spec.rb

@@ -9,6 +9,19 @@ module ForestLiana
       allow(ForestLiana::ScopeManager).to receive(:fetch_scopes).and_return(scopes)
     end
 
+    describe 'with not allowed aggregator' do
+      it 'should raise an error' do
+        expect {
+          LineStatGetter.new(Owner, {
+            timezone: "Europe/Paris",
+            aggregator: "eval",
+            timeRange: "Week",
+            groupByFieldName: "`ls`",
+          }, user)
+        }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid aggregate function')
+      end
+    end
+
     describe 'Check client_timezone function' do
       describe 'with a SQLite database' do
         it 'should return false' do

data/spec/services/forest_liana/pie_stat_getter_spec.rb

@@ -23,90 +23,113 @@ module ForestLiana
       }
     end
 
-    let(:model) { Tree }
-    let(:collection) { 'trees' }
-    let(:params) {
-      {
-        type: 'Pie',
-        sourceCollectionName: collection,
-        timezone: 'Europe/Paris',
-        aggregator: 'Count',
-        groupByFieldName: groupByFieldName
+    describe 'with not allowed aggregator' do
+      let(:scopes) { { } }
+      let(:model) { Tree }
+      let(:collection) { 'trees' }
+      let(:params) {
+        {
+          type: 'Pie',
+          sourceCollectionName: collection,
+          timezone: 'Europe/Paris',
+          aggregator: 'eval',
+          groupByFieldName: '`ls`'
+        }
       }
-    }
 
-    subject { PieStatGetter.new(model, params, user) }
+      it 'should raise an error' do
+        expect {
+          PieStatGetter.new(model, params, user)
+        }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid aggregate function')
+      end
+    end
 
-    describe 'with empty scopes' do
-      let(:scopes) { { } }
+    describe 'with valid aggregate function' do
+      let(:model) { Tree }
+      let(:collection) { 'trees' }
+      let(:params) {
+        {
+          type: 'Pie',
+          sourceCollectionName: collection,
+          timezone: 'Europe/Paris',
+          aggregator: 'Count',
+          groupByFieldName: groupByFieldName
+        }
+      }
 
-      describe 'with an aggregate on the name field' do
-        let(:groupByFieldName) { 'name' }
-
-        it 'should be as many categories as records count' do
-          subject.perform
-          expect(subject.record.value).to match_array([
-            {:key => "Old Tree n1", :value => 1},
-            {:key => "Old Tree n2", :value => 1},
-            {:key => "Old Tree n3", :value => 1},
-            {:key => "Old Tree n4", :value => 1},
-            {:key => "Young Tree n1", :value => 1},
-            {:key => "Young Tree n2", :value => 1},
-            {:key => "Young Tree n3", :value => 1},
-            {:key => "Young Tree n4", :value => 1},
-            {:key => "Young Tree n5", :value => 1}
-          ])
+      subject { PieStatGetter.new(model, params, user) }
+
+      describe 'with empty scopes' do
+        let(:scopes) { { } }
+
+        describe 'with an aggregate on the name field' do
+          let(:groupByFieldName) { 'name' }
+
+          it 'should be as many categories as records count' do
+            subject.perform
+            expect(subject.record.value).to match_array([
+              {:key => "Old Tree n1", :value => 1},
+              {:key => "Old Tree n2", :value => 1},
+              {:key => "Old Tree n3", :value => 1},
+              {:key => "Old Tree n4", :value => 1},
+              {:key => "Young Tree n1", :value => 1},
+              {:key => "Young Tree n2", :value => 1},
+              {:key => "Young Tree n3", :value => 1},
+              {:key => "Young Tree n4", :value => 1},
+              {:key => "Young Tree n5", :value => 1}
+            ])
+          end
         end
-      end
 
-      describe 'with an aggregate on the age field' do
-        let(:groupByFieldName) { 'age' }
+        describe 'with an aggregate on the age field' do
+          let(:groupByFieldName) { 'age' }
 
-        it 'should be as many categories as different ages among records' do
-          subject.perform
-          expect(subject.record.value).to eq [{ :key => 3, :value => 5}, { :key => 15, :value => 4 }]
+          it 'should be as many categories as different ages among records' do
+            subject.perform
+            expect(subject.record.value).to eq [{ :key => 3, :value => 5}, { :key => 15, :value => 4 }]
+          end
         end
       end
-    end
 
-    describe 'with scopes' do
-      let(:scopes) {
-        {
-          'Tree' => {
-            'scope'=> {
-              'filter'=> {
-                'aggregator' => 'and',
-                'conditions' => [
-                  { 'field' => 'age', 'operator' => 'less_than', 'value' => 10 }
-                ]
-              },
-              'dynamicScopesValues' => { }
+      describe 'with scopes' do
+        let(:scopes) {
+          {
+            'Tree' => {
+              'scope'=> {
+                'filter'=> {
+                  'aggregator' => 'and',
+                  'conditions' => [
+                    { 'field' => 'age', 'operator' => 'less_than', 'value' => 10 }
+                  ]
+                },
+                'dynamicScopesValues' => { }
+              }
             }
           }
         }
-      }
 
-      describe 'with an aggregate on the name field' do
-        let(:groupByFieldName) { 'name' }
-
-        it 'should be as many categories as records inside the scope' do
-          subject.perform
-          expect(subject.record.value).to match_array([
-            {:key => "Young Tree n1", :value => 1},
-            {:key => "Young Tree n2", :value => 1},
-            {:key => "Young Tree n3", :value => 1},
-            {:key => "Young Tree n4", :value => 1},
-            {:key => "Young Tree n5", :value => 1}
-          ])
+        describe 'with an aggregate on the name field' do
+          let(:groupByFieldName) { 'name' }
+
+          it 'should be as many categories as records inside the scope' do
+            subject.perform
+            expect(subject.record.value).to match_array([
+              {:key => "Young Tree n1", :value => 1},
+              {:key => "Young Tree n2", :value => 1},
+              {:key => "Young Tree n3", :value => 1},
+              {:key => "Young Tree n4", :value => 1},
+              {:key => "Young Tree n5", :value => 1}
+            ])
+          end
         end
-      end
 
-      describe 'with an aggregate on the age field' do
-        let(:groupByFieldName) { 'age' }
+        describe 'with an aggregate on the age field' do
+          let(:groupByFieldName) { 'age' }
 
-        it 'should be only one category' do
-          subject.perform
-          expect(subject.record.value).to eq [{ :key => 3, :value => 5}]
+          it 'should be only one category' do
+            subject.perform
+            expect(subject.record.value).to eq [{ :key => 3, :value => 5}]
+          end
         end
       end
     end

data/spec/services/forest_liana/schema_adapter_spec.rb

@@ -1,6 +1,64 @@
 module ForestLiana
   describe SchemaAdapter do
     describe 'perform' do
+      context 'with polymorphic association' do
+        it 'should define the association with the referenced models' do
+          collection = ForestLiana.apimap.find do |object|
+            object.name.to_s == ForestLiana.name_for(Address)
+          end
+          field = collection.fields.find { |field| field[:field] == 'addressable' }
+
+          expect(field).to eq(
+            {
+              field: "addressable",
+              type: "Number",
+              relationship: "BelongsTo",
+              reference: "addressable.id",
+              inverse_of: "address",
+              is_filterable: false,
+              is_sortable: true,
+              is_read_only: false,
+              is_required: false,
+              is_virtual: false,
+              default_value: nil,
+              integration: nil,
+              relationships: nil,
+              widget: nil,
+              validations: [],
+              polymorphic_referenced_models: ['User']
+            }
+          )
+        end
+
+        it 'should remove the polymorphic attributes(_id and _type)' do
+          collection = ForestLiana.apimap.find do |object|
+            object.name.to_s == ForestLiana.name_for(Address)
+          end
+          removed_fields = collection.fields.select do
+            |field| field[:field] == 'addressable_id' ||  field[:field] == 'addressable_type'
+          end
+
+          expect(removed_fields).to be_empty
+        end
+
+        context 'when the polymorphic support was disabled' do
+          it 'should not define the association' do
+            ENV['ENABLE_SUPPORT_POLYMORPHISM'] = 'false'
+            Bootstrapper.new(true)
+            collection = ForestLiana.apimap.find do |object|
+              object.name.to_s == ForestLiana.name_for(Address)
+            end
+            association = collection.fields.find { |field| field[:field] == 'addressable' }
+            fields = collection.fields.select do |field|
+              field[:field] == 'addressable_id' || field[:field] == 'addressable_type'
+            end
+
+            expect(association).to be_nil
+            expect(fields.size).to eq(2)
+          end
+        end
+      end
+
       context 'with an "unhandled" column types (binary, postgis geography, ...)' do
         it 'should not define theses column in the schema' do
           collection = ForestLiana.apimap.find do |object|

data/spec/services/forest_liana/value_stat_getter_spec.rb

@@ -15,80 +15,103 @@ module ForestLiana
       Tree.create!(name: 'Tree n3', age: 4, island: island, owner: king, cutter: villager)
     end
 
-    let(:params) {
-      {
-        type: "Value",
-        sourceCollectionName: sourceCollectionName,
-        timezone: "Europe/Paris",
-        aggregator: "Count",
-        filter: filter
+    describe 'with not allowed aggregator' do
+      let(:model) { User }
+      let(:collection) { 'users' }
+      let(:scopes) { { } }
+      let(:params) {
+        {
+          type: "Value",
+          sourceCollectionName: collection,
+          timezone: "Europe/Paris",
+          aggregator: "eval",
+          aggregateFieldName: "`ls`"
+        }
       }
-    }
 
-    subject { ValueStatGetter.new(model, params, user) }
+      it 'should raise an error' do
+        expect {
+          ValueStatGetter.new(model, params, user)
+        }.to raise_error(ForestLiana::Errors::HTTP422Error, 'Invalid aggregate function')
+      end
+    end
 
-    describe 'with empty scopes' do
-      let(:scopes) { { } }
+    describe 'with valid aggregate function' do
+      let(:params) {
+        {
+          type: "Value",
+          sourceCollectionName: sourceCollectionName,
+          timezone: "Europe/Paris",
+          aggregator: "Count",
+          filter: filter
+        }
+      }
+
+      subject { ValueStatGetter.new(model, params, user) }
 
-      describe 'with a simple filter matching no entries' do
-        let(:model) { User }
-        let(:sourceCollectionName) { 'users' }
-        let(:filter) { { field: 'name', operator: 'in', value: ['Merry', 'Pippin'] }.to_json }
+      describe 'with empty scopes' do
+        let(:scopes) { { } }
 
-        it 'should have a countCurrent of 0' do
-          subject.perform
-          expect(subject.record.value[:countCurrent]).to eq 0
+        describe 'with a simple filter matching no entries' do
+          let(:model) { User }
+          let(:sourceCollectionName) { 'users' }
+          let(:filter) { { field: 'name', operator: 'in', value: ['Merry', 'Pippin'] }.to_json }
+
+          it 'should have a countCurrent of 0' do
+            subject.perform
+            expect(subject.record.value[:countCurrent]).to eq 0
+          end
         end
-      end
 
-      describe 'with a filter on a belongs_to string field' do
-        let(:model) { Tree }
-        let(:sourceCollectionName) { 'trees' }
-        let(:filter) { { field: 'owner:name', operator: 'equal', value: 'Aragorn' }.to_json }
+        describe 'with a filter on a belongs_to string field' do
+          let(:model) { Tree }
+          let(:sourceCollectionName) { 'trees' }
+          let(:filter) { { field: 'owner:name', operator: 'equal', value: 'Aragorn' }.to_json }
 
-        it 'should have a countCurrent of 2' do
-          subject.perform
-          expect(subject.record.value[:countCurrent]).to eq 2
+          it 'should have a countCurrent of 2' do
+            subject.perform
+            expect(subject.record.value[:countCurrent]).to eq 2
+          end
         end
-      end
 
-      describe 'with a filter on a belongs_to enum field' do
-        let(:model) { Tree }
-        let(:sourceCollectionName) { 'trees' }
-        let(:filter) { { field: 'owner:title', operator: 'equal', value: 'villager' }.to_json }
+        describe 'with a filter on a belongs_to enum field' do
+          let(:model) { Tree }
+          let(:sourceCollectionName) { 'trees' }
+          let(:filter) { { field: 'owner:title', operator: 'equal', value: 'villager' }.to_json }
 
-        it 'should have a countCurrent of 1' do
-          subject.perform
-          expect(subject.record.value[:countCurrent]).to eq 1
+          it 'should have a countCurrent of 1' do
+            subject.perform
+            expect(subject.record.value[:countCurrent]).to eq 1
+          end
         end
       end
-    end
 
-    describe 'with scopes' do
-      let(:scopes) {
-        {
-          'User' => {
-            'scope'=> {
-              'filter'=> {
-                'aggregator' => 'and',
-                'conditions' => [
-                  { 'field' => 'title', 'operator' => 'not_equal', 'value' => 'villager' }
-                ]
-              },
-              'dynamicScopesValues' => { }
+      describe 'with scopes' do
+        let(:scopes) {
+          {
+            'User' => {
+              'scope'=> {
+                'filter'=> {
+                  'aggregator' => 'and',
+                  'conditions' => [
+                    { 'field' => 'title', 'operator' => 'not_equal', 'value' => 'villager' }
+                  ]
+                },
+                'dynamicScopesValues' => { }
+              }
             }
           }
         }
-      }
 
-      describe 'with a filter on a belongs_to enum field' do
-        let(:model) { User }
-        let(:sourceCollectionName) { 'users' }
-        let(:filter) { { field: 'title', operator: 'equal', value: 'villager' }.to_json }
+        describe 'with a filter on a belongs_to enum field' do
+          let(:model) { User }
+          let(:sourceCollectionName) { 'users' }
+          let(:filter) { { field: 'title', operator: 'equal', value: 'villager' }.to_json }
 
-        it 'should have a countCurrent of 0' do
-          subject.perform
-          expect(subject.record.value[:countCurrent]).to eq 0
+          it 'should have a countCurrent of 0' do
+            subject.perform
+            expect(subject.record.value[:countCurrent]).to eq 0
+          end
         end
       end
     end

data/spec/spec_helper.rb

@@ -19,6 +19,8 @@ SimpleCov.add_filter ['app/services/forest_liana/ability/fetch.rb', 'lib/forest_
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
   ENV['RAILS_ENV'] = 'test'
+  ENV['ENABLE_SUPPORT_POLYMORPHISM'] = 'true'
+
   require File.expand_path('../dummy/config/environment', __FILE__)
 
   # rspec-expectations config goes here. You can use an alternate

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 8.0.16
+  version: 8.1.0
 platform: ruby
 authors:
 - Sandro Munda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-16 00:00:00.000000000 Z
+date: 2024-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -350,6 +350,7 @@ files:
 - spec/dummy/app/controllers/application_controller.rb
 - spec/dummy/app/controllers/forest/islands_controller.rb
 - spec/dummy/app/helpers/application_helper.rb
+- spec/dummy/app/models/address.rb
 - spec/dummy/app/models/application_record.rb
 - spec/dummy/app/models/car.rb
 - spec/dummy/app/models/driver.rb
@@ -403,6 +404,7 @@ files:
 - spec/dummy/db/migrate/20220719094450_create_drivers.rb
 - spec/dummy/db/migrate/20220727114450_create_manufacturers.rb
 - spec/dummy/db/migrate/20220727114930_add_columns_to_products.rb
+- spec/dummy/db/migrate/20231117084236_create_addresses.rb
 - spec/dummy/db/schema.rb
 - spec/dummy/lib/forest_liana/collections/island.rb
 - spec/dummy/lib/forest_liana/collections/location.rb
@@ -646,6 +648,7 @@ test_files:
 - spec/dummy/app/controllers/application_controller.rb
 - spec/dummy/app/controllers/forest/islands_controller.rb
 - spec/dummy/app/helpers/application_helper.rb
+- spec/dummy/app/models/address.rb
 - spec/dummy/app/models/application_record.rb
 - spec/dummy/app/models/car.rb
 - spec/dummy/app/models/driver.rb
@@ -699,6 +702,7 @@ test_files:
 - spec/dummy/db/migrate/20220719094450_create_drivers.rb
 - spec/dummy/db/migrate/20220727114450_create_manufacturers.rb
 - spec/dummy/db/migrate/20220727114930_add_columns_to_products.rb
+- spec/dummy/db/migrate/20231117084236_create_addresses.rb
 - spec/dummy/db/schema.rb
 - spec/dummy/lib/forest_liana/collections/island.rb
 - spec/dummy/lib/forest_liana/collections/location.rb