forest_admin_agent 1.12.5 → 1.12.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 269748d517e3b35451f5b029a355b0c4ba4b3edb88d573c154a68b7afbd489a7
-  data.tar.gz: '079f48afc932a914ce14b9c113b439ba94db05a7af00f411931aa04af3b87f2f'
+  metadata.gz: fd573234b76fd50731dee629e11f0f4aaf920752620bfd8578691f8c33cefc79
+  data.tar.gz: 4df7f0a817d9ed945e45f9298258d98e7da2ebd2931776c89f0716812490209c
 SHA512:
-  metadata.gz: f13fe2d602b8c2e3bdd09c10e9af23e85dcd39cd3b7fa4efec8977269920d89510ee36844ff7eb5ef76d9a938b4931c0733c39a8369d8ce91bab12f7a3057a57
-  data.tar.gz: '059d5f1be122d042b6decf7ebe5e353adfc09a9c21bcddf9f49d581ee1030b35a0dc7b69fdef2847215e20e8df65baef93e635d129ff9d0cd19fd4831123ae0b'
+  metadata.gz: f7a71681bef6e70366de3ccc34482f924a9a45199d724705d46ebdb60371be315775196e57084d97e2e41513c20d57a60945cf1d8938eba5cadd856c5de8f3ff
+  data.tar.gz: c58258f27f3725e02c2d02ced97f322b9289b36ddb82777116d78235ec5a380662491c0f859167da7db3b18461519ef8caa5bc61308038b776bb7b72b830c4d0

data/lib/forest_admin_agent/routes/action/actions.rb

@@ -159,9 +159,9 @@ module ForestAdminAgent
           unless attributes[:parent_association_name].nil?
             relation = attributes[:parent_association_name]
             parent = @datasource.get_collection(attributes[:parent_collection_name])
-            parent_id = Utils::Id.unpack_id(parent, attributes[:parent_collection_id])
+            parent_primary_key_values = Utils::Id.unpack_id(parent, attributes[:parent_collection_id])
 
-            filter = FilterFactory.make_foreign_filter(parent, parent_id, relation, @caller, filter)
+            filter = FilterFactory.make_foreign_filter(parent, parent_primary_key_values, relation, @caller, filter)
           end
 
           filter

data/lib/forest_admin_agent/routes/resources/delete.rb

@@ -19,8 +19,8 @@ module ForestAdminAgent
         def handle_request(args = {})
           build(args)
           @permissions.can?(:delete, @collection)
-          id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
-          delete_records(args, { ids: [id], are_excluded: false })
+          primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          delete_records(args, { ids: [primary_key_values], are_excluded: false })
 
           { content: nil, status: 204 }
         end
@@ -41,11 +41,20 @@ module ForestAdminAgent
           @collection.schema[:fields].each_value do |field_schema|
             next unless ['PolymorphicOneToOne', 'PolymorphicOneToMany'].include?(field_schema.type)
 
+            origin_values = selection_ids[:ids].map do |pk_hash|
+              if pk_hash.is_a?(Hash)
+                pk_hash[field_schema.origin_key_target]
+              else
+                pk_names = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(@collection)
+                index = pk_names.index(field_schema.origin_key_target)
+                pk_hash[index] if index
+              end
+            end
+
             condition_tree = Nodes::ConditionTreeBranch.new(
               'And',
               [
-                Nodes::ConditionTreeLeaf.new(field_schema.origin_key, Operators::IN,
-                                             selection_ids[:ids].map { |value| value['id'] }),
+                Nodes::ConditionTreeLeaf.new(field_schema.origin_key, Operators::IN, origin_values),
                 Nodes::ConditionTreeLeaf.new(field_schema.origin_type_field, Operators::EQUAL,
                                              @collection.name.gsub('__', '::'))
               ]

data/lib/forest_admin_agent/routes/resources/related/associate_related.rb

@@ -24,17 +24,18 @@ module ForestAdminAgent
             build(args)
             @permissions.can?(:edit, @collection)
 
-            parent_id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
-            target_relation_id = Utils::Id.unpack_id(@child_collection, args[:params]['data'][0]['id'], with_key: true)
+            parent_primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            target_primary_key_values = Utils::Id.unpack_id(@child_collection, args[:params]['data'][0]['id'],
+                                                            with_key: true)
             relation = Schema.get_to_many_relation(@collection, args[:params]['relation_name'])
 
             case relation.type
             when 'OneToMany'
-              associate_one_to_many(relation, parent_id, target_relation_id)
+              associate_one_to_many(relation, parent_primary_key_values, target_primary_key_values)
             when 'ManyToMany'
-              associate_many_to_many(relation, parent_id, target_relation_id)
+              associate_many_to_many(relation, parent_primary_key_values, target_primary_key_values)
             when 'PolymorphicOneToMany'
-              associate_polymorphic_one_to_many(relation, parent_id, target_relation_id)
+              associate_polymorphic_one_to_many(relation, parent_primary_key_values, target_primary_key_values)
             end
 
             { content: nil, status: 204 }
@@ -42,9 +43,9 @@ module ForestAdminAgent
 
           private
 
-          def associate_one_to_many(relation, parent_id, target_relation_id)
+          def associate_one_to_many(relation, parent_primary_key_values, target_primary_key_values)
             id = Schema.primary_keys(@child_collection)[0]
-            value = Collection.get_value(@child_collection, @caller, target_relation_id, id)
+            value = Collection.get_value(@child_collection, @caller, target_primary_key_values, id)
             filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
@@ -53,14 +54,14 @@ module ForestAdminAgent
                 ]
               )
             )
-            value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
+            value = Collection.get_value(@collection, @caller, parent_primary_key_values, relation.origin_key_target)
 
             @child_collection.update(@caller, filter, { relation.origin_key => value })
           end
 
-          def associate_polymorphic_one_to_many(relation, parent_id, target_relation_id)
+          def associate_polymorphic_one_to_many(relation, parent_primary_key_values, target_primary_key_values)
             id = Schema.primary_keys(@child_collection)[0]
-            value = Collection.get_value(@child_collection, @caller, target_relation_id, id)
+            value = Collection.get_value(@child_collection, @caller, target_primary_key_values, id)
             filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
@@ -70,7 +71,7 @@ module ForestAdminAgent
               )
             )
 
-            value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
+            value = Collection.get_value(@collection, @caller, parent_primary_key_values, relation.origin_key_target)
 
             @child_collection.update(
               @caller,
@@ -79,11 +80,11 @@ module ForestAdminAgent
             )
           end
 
-          def associate_many_to_many(relation, parent_id, target_relation_id)
+          def associate_many_to_many(relation, parent_primary_key_values, target_primary_key_values)
             id = Schema.primary_keys(@child_collection)[0]
-            foreign_value = Collection.get_value(@child_collection, @caller, target_relation_id, id)
+            foreign_value = Collection.get_value(@child_collection, @caller, target_primary_key_values, id)
             id = Schema.primary_keys(@collection)[0]
-            origin_value = Collection.get_value(@collection, @caller, parent_id, id)
+            origin_value = Collection.get_value(@collection, @caller, parent_primary_key_values, id)
             record = { relation.origin_key => origin_value, relation.foreign_key => foreign_value }
 
             through_collection = @datasource.get_collection(relation.through_collection)

data/lib/forest_admin_agent/routes/resources/related/count_related.rb

@@ -25,10 +25,10 @@ module ForestAdminAgent
 
             if @child_collection.is_countable?
               filter = Filter.new(condition_tree: @permissions.get_scope(@collection))
-              id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+              primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
               result = Collection.aggregate_relation(
                 @collection,
-                id,
+                primary_key_values,
                 args[:params]['relation_name'],
                 @caller,
                 filter,

data/lib/forest_admin_agent/routes/resources/related/csv_related.rb

@@ -34,8 +34,8 @@ module ForestAdminAgent
             )
             projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@child_collection, args)
 
-            # Get the parent record ID
-            id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            # Get the parent record primary keys
+            primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
             relation_name = args[:params]['relation_name']
 
             # Generate timestamp for filename
@@ -48,7 +48,7 @@ module ForestAdminAgent
             list_records = lambda do |batch_filter|
               ForestAdminDatasourceToolkit::Utils::Collection.list_relation(
                 @collection,
-                id,
+                primary_key_values,
                 relation_name,
                 @caller,
                 batch_filter,

data/lib/forest_admin_agent/routes/resources/related/dissociate_related.rb

@@ -22,7 +22,7 @@ module ForestAdminAgent
           def handle_request(args = {})
             build(args)
 
-            parent_id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            parent_primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
             is_delete_mode = !args.dig(:params, :delete).nil?
 
             if is_delete_mode
@@ -35,11 +35,13 @@ module ForestAdminAgent
             relation = Schema.get_to_many_relation(@collection, args[:params]['relation_name'])
 
             if ['OneToMany', 'PolymorphicOneToMany'].include?(relation.type)
-              dissociate_or_delete_one_to_many(relation, args[:params]['relation_name'], parent_id, is_delete_mode,
-                                               filter)
+              dissociate_or_delete_one_to_many(
+                relation, args[:params]['relation_name'], parent_primary_key_values, is_delete_mode, filter
+              )
             else
-              dissociate_or_delete_many_to_many(relation, args[:params]['relation_name'], parent_id, is_delete_mode,
-                                                filter)
+              dissociate_or_delete_many_to_many(
+                relation, args[:params]['relation_name'], parent_primary_key_values, is_delete_mode, filter
+              )
             end
 
             { content: nil, status: 204 }
@@ -47,8 +49,10 @@ module ForestAdminAgent
 
           private
 
-          def dissociate_or_delete_one_to_many(relation, relation_name, parent_id, is_delete_mode, filter)
-            foreign_filter = FilterFactory.make_foreign_filter(@collection, parent_id, relation_name, @caller, filter)
+          def dissociate_or_delete_one_to_many(relation, relation_name, parent_primary_key_values, is_delete_mode,
+                                               filter)
+            foreign_filter = FilterFactory.make_foreign_filter(@collection, parent_primary_key_values, relation_name,
+                                                               @caller, filter)
 
             if is_delete_mode
               @child_collection.delete(@caller, foreign_filter)
@@ -62,13 +66,16 @@ module ForestAdminAgent
             end
           end
 
-          def dissociate_or_delete_many_to_many(relation, relation_name, parent_id, is_delete_mode, filter)
+          def dissociate_or_delete_many_to_many(relation, relation_name, parent_primary_key_values, is_delete_mode,
+                                                filter)
             through_collection = @datasource.get_collection(relation.through_collection)
 
             if is_delete_mode
               # Generate filters _BEFORE_ deleting stuff, otherwise things break.
-              foreign_filter = FilterFactory.make_foreign_filter(@collection, parent_id, relation_name, @caller, filter)
-              through_filter = FilterFactory.make_through_filter(@collection, parent_id, relation_name, @caller, filter)
+              foreign_filter = FilterFactory.make_foreign_filter(@collection, parent_primary_key_values, relation_name,
+                                                                 @caller, filter)
+              through_filter = FilterFactory.make_through_filter(@collection, parent_primary_key_values, relation_name,
+                                                                 @caller, filter)
 
               # Delete records from through collection
               through_collection.delete(@caller, through_filter)
@@ -78,7 +85,8 @@ module ForestAdminAgent
               # - the underlying database/api is not cascading deletes
               @child_collection.delete(@caller, foreign_filter)
             else
-              through_filter = FilterFactory.make_through_filter(@collection, parent_id, relation_name, @caller, filter)
+              through_filter = FilterFactory.make_through_filter(@collection, parent_primary_key_values, relation_name,
+                                                                 @caller, filter)
               through_collection.delete(@caller, through_filter)
             end
           end

data/lib/forest_admin_agent/routes/resources/related/list_related.rb

@@ -35,10 +35,10 @@ module ForestAdminAgent
               sort: ForestAdminAgent::Utils::QueryStringParser.parse_sort(@child_collection, args)
             )
             projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@child_collection, args)
-            id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+            primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
             records = Collection.list_relation(
               @collection,
-              id,
+              primary_key_values,
               args[:params]['relation_name'],
               @caller,
               filter,

data/lib/forest_admin_agent/routes/resources/related/update_related.rb

@@ -25,21 +25,21 @@ module ForestAdminAgent
             @permissions.can?(:edit, @collection)
 
             relation = @collection.schema[:fields][args[:params]['relation_name']]
-            parent_id = Utils::Id.unpack_id(@collection, args[:params]['id'])
+            parent_primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'])
 
-            linked_id = if (id = args.dig(:params, 'data', 'id'))
-                          Utils::Id.unpack_id(@child_collection, id)
-                        end
+            linked_primary_key_values = if (id = args.dig(:params, 'data', 'id'))
+                                          Utils::Id.unpack_id(@child_collection, id)
+                                        end
 
             case relation.type
             when 'ManyToOne'
-              update_many_to_one(relation, parent_id, linked_id)
+              update_many_to_one(relation, parent_primary_key_values, linked_primary_key_values)
             when 'PolymorphicManyToOne'
-              update_polymorphic_many_to_one(relation, parent_id, linked_id)
+              update_polymorphic_many_to_one(relation, parent_primary_key_values, linked_primary_key_values)
             when 'OneToOne'
-              update_one_to_one(relation, parent_id, linked_id)
+              update_one_to_one(relation, parent_primary_key_values, linked_primary_key_values)
             when 'PolymorphicOneToOne'
-              update_polymorphic_one_to_one(relation, parent_id, linked_id)
+              update_polymorphic_one_to_one(relation, parent_primary_key_values, linked_primary_key_values)
             end
 
             { content: nil, status: 204 }
@@ -47,26 +47,27 @@ module ForestAdminAgent
 
           private
 
-          def update_many_to_one(relation, parent_id, linked_id)
-            foreign_value = if linked_id
-                              Collection.get_value(@child_collection, @caller, linked_id, relation.foreign_key_target)
+          def update_many_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+            foreign_value = if linked_primary_key_values
+                              Collection.get_value(@child_collection, @caller, linked_primary_key_values,
+                                                   relation.foreign_key_target)
                             end
-            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@collection, [parent_id])
+            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@collection, [parent_primary_key_values])
             @collection.update(@caller, Filter.new(condition_tree: fk_owner), { relation.foreign_key => foreign_value })
           end
 
-          def update_polymorphic_many_to_one(relation, parent_id, linked_id)
-            foreign_value = if linked_id
+          def update_polymorphic_many_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+            foreign_value = if linked_primary_key_values
                               Collection.get_value(
                                 @child_collection,
                                 @caller,
-                                linked_id,
+                                linked_primary_key_values,
                                 relation.foreign_key_targets[@child_collection.name]
                               )
                             end
 
             polymorphic_type = @child_collection.name.gsub('__', '::')
-            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@collection, [parent_id])
+            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@collection, [parent_primary_key_values])
             @collection.update(
               @caller,
               Filter.new(condition_tree: fk_owner),
@@ -77,22 +78,24 @@ module ForestAdminAgent
             )
           end
 
-          def update_polymorphic_one_to_one(relation, parent_id, linked_id)
-            origin_value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
+          def update_polymorphic_one_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+            origin_value = Collection.get_value(@collection, @caller, parent_primary_key_values,
+                                                relation.origin_key_target)
 
-            break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_id)
-            create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_id)
+            break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+            create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
           end
 
-          def update_one_to_one(relation, parent_id, linked_id)
-            origin_value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
+          def update_one_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+            origin_value = Collection.get_value(@collection, @caller, parent_primary_key_values,
+                                                relation.origin_key_target)
 
-            break_old_one_to_one_relationship(relation, origin_value, linked_id)
-            create_new_one_to_one_relationship(relation, origin_value, linked_id)
+            break_old_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+            create_new_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
           end
 
-          def break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_id)
-            linked_id ||= []
+          def break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+            linked_primary_key_values ||= []
 
             old_fk_owner_filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
@@ -115,7 +118,7 @@ module ForestAdminAgent
                   ),
                   # Don't set the new record's field to null
                   # if it's already initialized with the right value
-                  ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id]).inverse
+                  ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_primary_key_values]).inverse
                 ]
               )
             )
@@ -133,10 +136,10 @@ module ForestAdminAgent
             )
           end
 
-          def create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_id)
-            return unless linked_id
+          def create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+            return unless linked_primary_key_values
 
-            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id])
+            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_primary_key_values])
 
             @child_collection.update(
               @caller,
@@ -151,8 +154,8 @@ module ForestAdminAgent
             )
           end
 
-          def break_old_one_to_one_relationship(relation, origin_value, linked_id)
-            linked_id ||= []
+          def break_old_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+            linked_primary_key_values ||= []
             old_fk_owner_filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
@@ -164,7 +167,7 @@ module ForestAdminAgent
                   ),
                   # Don't set the new record's field to null
                   # if it's already initialized with the right value
-                  ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id]).inverse
+                  ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_primary_key_values]).inverse
                 ]
               )
             )
@@ -178,10 +181,10 @@ module ForestAdminAgent
             @child_collection.update(@caller, old_fk_owner_filter, { relation.origin_key => nil })
           end
 
-          def create_new_one_to_one_relationship(relation, origin_value, linked_id)
-            return unless linked_id
+          def create_new_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+            return unless linked_primary_key_values
 
-            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id])
+            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_primary_key_values])
 
             @child_collection.update(
               @caller,

data/lib/forest_admin_agent/routes/resources/show.rb

@@ -17,8 +17,8 @@ module ForestAdminAgent
           build(args)
           @permissions.can?(:read, @collection)
           scope = @permissions.get_scope(@collection)
-          id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
-          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [id])
+          primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [primary_key_values])
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )

data/lib/forest_admin_agent/routes/resources/store.rb

@@ -41,7 +41,7 @@ module ForestAdminAgent
             schema = @collection.schema[:fields][field]
             next unless %w[OneToOne PolymorphicOneToOne].include?(schema.type)
 
-            id = Utils::Id.unpack_id(@collection, value['data']['id'], with_key: true)
+            primary_key_values = Utils::Id.unpack_id(@collection, value['data']['id'], with_key: true)
             foreign_collection = @datasource.get_collection(schema.foreign_collection)
             # Load the value that will be used as origin_key
             origin_value = record[schema.origin_key_target]
@@ -49,7 +49,7 @@ module ForestAdminAgent
             # update new relation (may update zero or one records).
             patch = { schema.origin_key => origin_value }
             patch[schema.origin_type_field] = @collection.name.gsub('__', '::') if schema.type == 'PolymorphicOneToOne'
-            condition_tree = ConditionTree::ConditionTreeFactory.match_records(foreign_collection, [id])
+            condition_tree = ConditionTree::ConditionTreeFactory.match_records(foreign_collection, [primary_key_values])
             filter = Filter.new(condition_tree: condition_tree)
             foreign_collection.update(@caller, filter, patch)
           end

data/lib/forest_admin_agent/routes/resources/update.rb

@@ -18,8 +18,8 @@ module ForestAdminAgent
           build(args)
           @permissions.can?(:edit, @collection)
           scope = @permissions.get_scope(@collection)
-          id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
-          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [id])
+          primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [primary_key_values])
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )

data/lib/forest_admin_agent/routes/resources/update_field.rb

@@ -25,7 +25,7 @@ module ForestAdminAgent
         def handle_request(args = {})
           build(args)
 
-          record_id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
           field_name = args[:params]['field_name']
           array_index = parse_index(args[:params]['index'])
 
@@ -34,7 +34,7 @@ module ForestAdminAgent
           field_schema = @collection.schema[:fields][field_name]
           validate_array_field!(field_schema, field_name)
 
-          record = fetch_record(record_id)
+          record = fetch_record(primary_key_values)
 
           array = record[field_name]
           validate_array_value!(array, field_name, array_index)
@@ -45,7 +45,7 @@ module ForestAdminAgent
           updated_array[array_index] = new_value
 
           scope = @permissions.get_scope(@collection)
-          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [record_id])
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [primary_key_values])
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )
@@ -87,9 +87,9 @@ module ForestAdminAgent
           raise Http::Exceptions::ValidationError, e.message
         end
 
-        def fetch_record(record_id)
+        def fetch_record(primary_key_values)
           scope = @permissions.get_scope(@collection)
-          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [record_id])
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [primary_key_values])
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )

data/lib/forest_admin_agent/utils/condition_tree_parser.rb

@@ -12,7 +12,7 @@ module ForestAdminAgent
       def self.from_plain_object(collection, filters)
         if leaf?(filters)
           operator = filters[:operator].titleize.tr(' ', '_').downcase
-          value = parse_value(collection, filters)
+          value = parse_value(collection, filters.merge(operator: operator))
 
           return ConditionTreeLeaf.new(filters[:field], operator, value)
         end
@@ -31,18 +31,52 @@ module ForestAdminAgent
 
       def self.parse_value(collection, leaf)
         schema = Collection.get_field_schema(collection, leaf[:field])
+        expected_type = get_expected_type_for_condition(leaf, schema)
 
-        if leaf[:operator] == Operators::IN && leaf[:field].is_a?(String)
-          values = leaf[:value].split(',').map(&:strip)
+        cast_to_type(leaf[:value], expected_type)
+      end
 
-          return values.map { |item| !%w[false 0 no].include?(item) } if schema.column_type == 'Boolean'
+      def self.get_expected_type_for_condition(leaf, schema)
+        operators_expecting_number = [
+          Operators::SHORTER_THAN,
+          Operators::LONGER_THAN,
+          Operators::AFTER_X_HOURS_AGO,
+          Operators::BEFORE_X_HOURS_AGO,
+          Operators::PREVIOUS_X_DAYS,
+          Operators::PREVIOUS_X_DAYS_TO_DATE
+        ]
 
-          return values.map(&:to_f).select { |item| item.is_a? Numeric } if schema.column_type == 'Number'
+        return 'Number' if operators_expecting_number.include?(leaf[:operator])
 
-          return values
+        if [Operators::IN, Operators::NOT_IN, Operators::INCLUDES_ALL].include?(leaf[:operator])
+          return [schema.column_type]
         end
 
-        leaf[:value]
+        schema.column_type
+      end
+
+      def self.cast_to_type(value, expected_type)
+        return value if value.nil?
+
+        if expected_type.is_a?(Array)
+          items = value.is_a?(String) ? value.split(',').map(&:strip) : value
+          filter_fn = expected_type[0] == 'Number' ? ->(item) { item.is_a?(Numeric) } : ->(_) { true }
+
+          return value unless items.is_a?(Array)
+
+          return items.map { |item| cast_to_type(item, expected_type[0]) }.select(&filter_fn)
+        end
+
+        case expected_type
+        when 'String', 'Dateonly', 'Date'
+          value.to_s
+        when 'Number'
+          value.to_f
+        when 'Boolean'
+          !%w[false 0 no].include?(value.to_s)
+        else
+          value
+        end
       end
 
       def self.leaf?(filters)

data/lib/forest_admin_agent/utils/schema/schema_emitter.rb

@@ -6,7 +6,7 @@ module ForestAdminAgent
     module Schema
       class SchemaEmitter
         LIANA_NAME = "agent-ruby"
-        LIANA_VERSION = "1.12.5"
+        LIANA_VERSION = "1.12.7"
 
         def self.generate(datasource)
           datasource.collections

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.12.5"
+  VERSION = "1.12.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.12.5
+  version: 1.12.7
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-24 00:00:00.000000000 Z
+date: 2025-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport