forest_admin_agent 1.12.13 → 1.12.15

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

@@ -21,25 +21,25 @@ module ForestAdminAgent
           end
 
           def handle_request(args = {})
-            build(args)
-            @permissions.can?(:edit, @collection)
+            context = build(args)
+            context.permissions.can?(:edit, context.collection)
 
-            relation = @collection.schema[:fields][args[:params]['relation_name']]
-            parent_primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'])
+            relation = context.collection.schema[:fields][args[:params]['relation_name']]
+            parent_primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'])
 
             linked_primary_key_values = if (id = args.dig(:params, 'data', 'id'))
-                                          Utils::Id.unpack_id(@child_collection, id)
+                                          Utils::Id.unpack_id(context.child_collection, id)
                                         end
 
             case relation.type
             when 'ManyToOne'
-              update_many_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+              update_many_to_one(relation, parent_primary_key_values, linked_primary_key_values, context)
             when 'PolymorphicManyToOne'
-              update_polymorphic_many_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+              update_polymorphic_many_to_one(relation, parent_primary_key_values, linked_primary_key_values, context)
             when 'OneToOne'
-              update_one_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+              update_one_to_one(relation, parent_primary_key_values, linked_primary_key_values, context)
             when 'PolymorphicOneToOne'
-              update_polymorphic_one_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+              update_polymorphic_one_to_one(relation, parent_primary_key_values, linked_primary_key_values, context)
             end
 
             { content: nil, status: 204 }
@@ -47,29 +47,30 @@ module ForestAdminAgent
 
           private
 
-          def update_many_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+          def update_many_to_one(relation, parent_primary_key_values, linked_primary_key_values, context)
             foreign_value = if linked_primary_key_values
-                              Collection.get_value(@child_collection, @caller, linked_primary_key_values,
+                              Collection.get_value(context.child_collection, context.caller, linked_primary_key_values,
                                                    relation.foreign_key_target)
                             end
-            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 })
+            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(context.collection, [parent_primary_key_values])
+            context.collection.update(context.caller, Filter.new(condition_tree: fk_owner),
+                                      { relation.foreign_key => foreign_value })
           end
 
-          def update_polymorphic_many_to_one(relation, parent_primary_key_values, linked_primary_key_values)
+          def update_polymorphic_many_to_one(relation, parent_primary_key_values, linked_primary_key_values, context)
             foreign_value = if linked_primary_key_values
                               Collection.get_value(
-                                @child_collection,
-                                @caller,
+                                context.child_collection,
+                                context.caller,
                                 linked_primary_key_values,
-                                relation.foreign_key_targets[@child_collection.name]
+                                relation.foreign_key_targets[context.child_collection.name]
                               )
                             end
 
-            polymorphic_type = @child_collection.name.gsub('__', '::')
-            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@collection, [parent_primary_key_values])
-            @collection.update(
-              @caller,
+            polymorphic_type = context.child_collection.name.gsub('__', '::')
+            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(context.collection, [parent_primary_key_values])
+            context.collection.update(
+              context.caller,
               Filter.new(condition_tree: fk_owner),
               {
                 relation.foreign_key => foreign_value,
@@ -78,29 +79,29 @@ module ForestAdminAgent
             )
           end
 
-          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,
+          def update_polymorphic_one_to_one(relation, parent_primary_key_values, linked_primary_key_values, context)
+            origin_value = Collection.get_value(context.collection, context.caller, parent_primary_key_values,
                                                 relation.origin_key_target)
 
-            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)
+            break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values, context)
+            create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values, context)
           end
 
-          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,
+          def update_one_to_one(relation, parent_primary_key_values, linked_primary_key_values, context)
+            origin_value = Collection.get_value(context.collection, context.caller, parent_primary_key_values,
                                                 relation.origin_key_target)
 
-            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)
+            break_old_one_to_one_relationship(relation, origin_value, linked_primary_key_values, context)
+            create_new_one_to_one_relationship(relation, origin_value, linked_primary_key_values, context)
           end
 
-          def break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+          def break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values, context)
             linked_primary_key_values ||= []
 
             old_fk_owner_filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
-                  @permissions.get_scope(@collection),
+                  context.permissions.get_scope(context.collection),
                   ConditionTree::Nodes::ConditionTreeBranch.new(
                     'And',
                     [
@@ -112,54 +113,58 @@ module ForestAdminAgent
                       ConditionTree::Nodes::ConditionTreeLeaf.new(
                         relation.origin_type_field,
                         ConditionTree::Operators::EQUAL,
-                        @collection.name.gsub('__', '::')
+                        context.collection.name.gsub('__', '::')
                       )
                     ]
                   ),
                   # 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_primary_key_values]).inverse
+                  ConditionTree::ConditionTreeFactory.match_ids(context.child_collection,
+                                                                [linked_primary_key_values]).inverse
                 ]
               )
             )
 
-            result = @child_collection.aggregate(@caller, old_fk_owner_filter, Aggregation.new(operation: 'Count'), 1)
+            result = context.child_collection.aggregate(context.caller, old_fk_owner_filter,
+                                                        Aggregation.new(operation: 'Count'), 1)
             return unless !(result[0]['value']).nil? && (result[0]['value']).positive?
 
             # Avoids updating records to null if it's not authorized by the ORM
             # and if there is no record to update (the filter returns no record)
 
-            @child_collection.update(
-              @caller,
+            context.child_collection.update(
+              context.caller,
               old_fk_owner_filter,
               { relation.origin_key => nil, relation.origin_type_field => nil }
             )
           end
 
-          def create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+          def create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_primary_key_values, context)
             return unless linked_primary_key_values
 
-            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_primary_key_values])
+            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(context.child_collection,
+                                                                         [linked_primary_key_values])
 
-            @child_collection.update(
-              @caller,
+            context.child_collection.update(
+              context.caller,
               Filter.new(
                 condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                   [
-                    @permissions.get_scope(@collection), new_fk_owner
+                    context.permissions.get_scope(context.collection), new_fk_owner
                   ]
                 )
               ),
-              { relation.origin_key => origin_value, relation.origin_type_field => @collection.name.gsub('__', '::') }
+              { relation.origin_key => origin_value,
+                relation.origin_type_field => context.collection.name.gsub('__', '::') }
             )
           end
 
-          def break_old_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+          def break_old_one_to_one_relationship(relation, origin_value, linked_primary_key_values, context)
             linked_primary_key_values ||= []
             old_fk_owner_filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
-                  @permissions.get_scope(@collection),
+                  context.permissions.get_scope(context.collection),
                   ConditionTree::Nodes::ConditionTreeLeaf.new(
                     relation.origin_key,
                     ConditionTree::Operators::EQUAL,
@@ -167,30 +172,33 @@ 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_primary_key_values]).inverse
+                  ConditionTree::ConditionTreeFactory.match_ids(context.child_collection,
+                                                                [linked_primary_key_values]).inverse
                 ]
               )
             )
 
-            result = @child_collection.aggregate(@caller, old_fk_owner_filter, Aggregation.new(operation: 'Count'), 1)
+            result = context.child_collection.aggregate(context.caller, old_fk_owner_filter,
+                                                        Aggregation.new(operation: 'Count'), 1)
             return unless !(result[0]['value']).nil? && (result[0]['value']).positive?
 
             # Avoids updating records to null if it's not authorized by the ORM
             # and if there is no record to update (the filter returns no record)
 
-            @child_collection.update(@caller, old_fk_owner_filter, { relation.origin_key => nil })
+            context.child_collection.update(context.caller, old_fk_owner_filter, { relation.origin_key => nil })
           end
 
-          def create_new_one_to_one_relationship(relation, origin_value, linked_primary_key_values)
+          def create_new_one_to_one_relationship(relation, origin_value, linked_primary_key_values, context)
             return unless linked_primary_key_values
 
-            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_primary_key_values])
+            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(context.child_collection,
+                                                                         [linked_primary_key_values])
 
-            @child_collection.update(
-              @caller,
+            context.child_collection.update(
+              context.caller,
               Filter.new(condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
-                  @permissions.get_scope(@collection),
+                  context.permissions.get_scope(context.collection),
                   new_fk_owner
                 ]
               )),

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

@@ -14,18 +14,18 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can?(:read, @collection)
-          scope = @permissions.get_scope(@collection)
-          primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
-          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [primary_key_values])
+          context = build(args)
+          context.permissions.can?(:read, context.collection)
+          scope = context.permissions.get_scope(context.collection)
+          primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'], with_key: true)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(context.collection, [primary_key_values])
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )
 
-          projection = ProjectionFactory.all(@collection)
+          projection = ProjectionFactory.all(context.collection)
 
-          records = @collection.list(@caller, filter, projection)
+          records = context.collection.list(context.caller, filter, projection)
 
           raise Http::Exceptions::NotFoundError, 'Record does not exists' unless records.size.positive?
 
@@ -33,7 +33,7 @@ module ForestAdminAgent
             name: args[:params]['collection_name'],
             content: JSONAPI::Serializer.serialize(
               records[0],
-              class_name: @collection.name,
+              class_name: context.collection.name,
               is_collection: false,
               serializer: Serializer::ForestSerializer,
               include: projection.relations(only_keys: true)

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

@@ -14,44 +14,47 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can?(:add, @collection)
-          data = format_attributes(args)
-          record = @collection.create(@caller, data)
-          link_one_to_one_relations(args, record)
-          id = ForestAdminDatasourceToolkit::Utils::Record.primary_keys(@collection, record)
+          context = build(args)
+          context.permissions.can?(:add, context.collection)
+          data = format_attributes(args, context.collection)
+          record = context.collection.create(context.caller, data)
+          link_one_to_one_relations(args, record, context)
+          id = ForestAdminDatasourceToolkit::Utils::Record.primary_keys(context.collection, record)
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
-            condition_tree: ConditionTree::ConditionTreeFactory.match_ids(@collection, [id])
+            condition_tree: ConditionTree::ConditionTreeFactory.match_ids(context.collection, [id])
           )
-          records = @collection.list(@caller, filter, ProjectionFactory.all(@collection))
+          records = context.collection.list(context.caller, filter, ProjectionFactory.all(context.collection))
 
           {
             name: args[:params]['collection_name'],
             content: JSONAPI::Serializer.serialize(
               records[0],
               is_collection: false,
-              class_name: @collection.name,
+              class_name: context.collection.name,
               serializer: Serializer::ForestSerializer
             )
           }
         end
 
-        def link_one_to_one_relations(args, record)
+        def link_one_to_one_relations(args, record, context)
           args[:params][:data][:relationships]&.map do |field, value|
-            schema = @collection.schema[:fields][field]
+            schema = context.collection.schema[:fields][field]
             next unless %w[OneToOne PolymorphicOneToOne].include?(schema.type)
 
-            primary_key_values = Utils::Id.unpack_id(@collection, value['data']['id'], with_key: true)
-            foreign_collection = @datasource.get_collection(schema.foreign_collection)
+            primary_key_values = Utils::Id.unpack_id(context.collection, value['data']['id'], with_key: true)
+            foreign_collection = context.datasource.get_collection(schema.foreign_collection)
             # Load the value that will be used as origin_key
             origin_value = record[schema.origin_key_target]
 
             # 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'
+            if schema.type == 'PolymorphicOneToOne'
+              patch[schema.origin_type_field] =
+                context.collection.name.gsub('__', '::')
+            end
             condition_tree = ConditionTree::ConditionTreeFactory.match_records(foreign_collection, [primary_key_values])
             filter = Filter.new(condition_tree: condition_tree)
-            foreign_collection.update(@caller, filter, patch)
+            foreign_collection.update(context.caller, filter, patch)
           end
         end
       end

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

@@ -15,24 +15,24 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can?(:edit, @collection)
-          scope = @permissions.get_scope(@collection)
-          primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
-          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [primary_key_values])
+          context = build(args)
+          context.permissions.can?(:edit, context.collection)
+          scope = context.permissions.get_scope(context.collection)
+          primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'], with_key: true)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(context.collection, [primary_key_values])
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )
-          data = format_attributes(args)
-          @collection.update(@caller, filter, data)
-          records = @collection.list(@caller, filter, ProjectionFactory.all(@collection))
+          data = format_attributes(args, context.collection)
+          context.collection.update(context.caller, filter, data)
+          records = context.collection.list(context.caller, filter, ProjectionFactory.all(context.collection))
 
           {
             name: args[:params]['collection_name'],
             content: JSONAPI::Serializer.serialize(
               records[0],
               is_collection: false,
-              class_name: @collection.name,
+              class_name: context.collection.name,
               serializer: Serializer::ForestSerializer
             )
           }

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

@@ -23,18 +23,18 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
+          context = build(args)
 
-          primary_key_values = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          primary_key_values = Utils::Id.unpack_id(context.collection, args[:params]['id'], with_key: true)
           field_name = args[:params]['field_name']
           array_index = parse_index(args[:params]['index'])
 
-          @permissions.can?(:edit, @collection)
+          context.permissions.can?(:edit, context.collection)
 
-          field_schema = @collection.schema[:fields][field_name]
-          validate_array_field!(field_schema, field_name)
+          field_schema = context.collection.schema[:fields][field_name]
+          validate_array_field!(field_schema, field_name, context.collection)
 
-          record = fetch_record(primary_key_values)
+          record = fetch_record(primary_key_values, context)
 
           array = record[field_name]
           validate_array_value!(array, field_name, array_index)
@@ -44,21 +44,21 @@ module ForestAdminAgent
           updated_array = array.dup
           updated_array[array_index] = new_value
 
-          scope = @permissions.get_scope(@collection)
-          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [primary_key_values])
+          scope = context.permissions.get_scope(context.collection)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(context.collection, [primary_key_values])
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )
-          @collection.update(@caller, filter, { field_name => updated_array })
+          context.collection.update(context.caller, filter, { field_name => updated_array })
 
-          records = @collection.list(@caller, filter, ProjectionFactory.all(@collection))
+          records = context.collection.list(context.caller, filter, ProjectionFactory.all(context.collection))
 
           {
             name: args[:params]['collection_name'],
             content: JSONAPI::Serializer.serialize(
               records[0],
               is_collection: false,
-              class_name: @collection.name,
+              class_name: context.collection.name,
               serializer: Serializer::ForestSerializer
             )
           }
@@ -75,8 +75,8 @@ module ForestAdminAgent
           raise Http::Exceptions::ValidationError, "Invalid index: #{index_param}"
         end
 
-        def validate_array_field!(field_schema, field_name)
-          FieldValidator.validate(@collection, field_name)
+        def validate_array_field!(field_schema, field_name, collection)
+          FieldValidator.validate(collection, field_name)
           return if field_schema.column_type.is_a?(Array)
 
           raise Http::Exceptions::ValidationError,
@@ -87,13 +87,13 @@ module ForestAdminAgent
           raise Http::Exceptions::ValidationError, e.message
         end
 
-        def fetch_record(primary_key_values)
-          scope = @permissions.get_scope(@collection)
-          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [primary_key_values])
+        def fetch_record(primary_key_values, context)
+          scope = context.permissions.get_scope(context.collection)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(context.collection, [primary_key_values])
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
           )
-          records = @collection.list(@caller, filter, ProjectionFactory.all(@collection))
+          records = context.collection.list(context.caller, filter, ProjectionFactory.all(context.collection))
 
           raise Http::Exceptions::NotFoundError, 'Record not found' unless records&.any?
 

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.13"
+        LIANA_VERSION = "1.12.15"
 
         def self.generate(datasource)
           datasource.collections

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.12.13"
+  VERSION = "1.12.15"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.12.13
+  version: 1.12.15
 platform: ruby
 authors:
 - Matthieu
@@ -314,6 +314,7 @@ files:
 - lib/forest_admin_agent/routes/charts/api_chart_datasource.rb
 - lib/forest_admin_agent/routes/charts/charts.rb
 - lib/forest_admin_agent/routes/query_handler.rb
+- lib/forest_admin_agent/routes/request_context.rb
 - lib/forest_admin_agent/routes/resources/count.rb
 - lib/forest_admin_agent/routes/resources/csv.rb
 - lib/forest_admin_agent/routes/resources/delete.rb