forest_admin_agent 1.12.13 → 1.12.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcedc2aca2e7965829e92f88f166f74264dd820084052ae74d225beb3a166aa8
-  data.tar.gz: 8931db8225893bcb912b3a445d88f6323d58bac33caf166051b5753df84c3676
+  metadata.gz: d06c27d8cb7afd9c9e531c215dd12f253af4e0dc92f67496d45a789a925c8024
+  data.tar.gz: 93fa83fec26dcce76b175cdb1cafdbc2bf55a4d94bb91835a9ed7cb830e67da8
 SHA512:
-  metadata.gz: 6faf436c5fbf5a3facf3313644f02483b990f09eaf10bd99aba7a96a999c6d45b9c9b8b426eaa19152627a1cf42f33d87b00a495417a5382876d231f6ee8b15b
-  data.tar.gz: e9a7c9e2e5763539a1dea190ed0c3cd46a2b5fff17b0aa447660695ba58faa5d37bedc23cbfac48a7be8383ceeeb8abaa9a95df54e14ce9aefc6399931946f95
+  metadata.gz: 48ef7caf5cec3cb36abc575bf1f49b1c12c45c21380e0a579a5637feda6ed9d894f1a088019666526cc9ec688fc0018544917327aab82060370ba97278911dcc
+  data.tar.gz: 8b962f14fdc92733b8d4ed312d167d99169ad472c93ec885117a3569c691b271c3c0e64d37b221f42ecf62fc487a0af557d3ee0470e43d18d9768cd57ce091f9

data/lib/forest_admin_agent/routes/abstract_authenticated_route.rb

@@ -5,18 +5,20 @@ module ForestAdminAgent
         if args.dig(:headers, 'action_dispatch.remote_ip')
           Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
         end
-        @caller = Utils::QueryStringParser.parse_caller(args)
-        @permissions = ForestAdminAgent::Services::Permissions.new(@caller)
-        super
+
+        context = super
+        context.caller = Utils::QueryStringParser.parse_caller(args)
+        context.permissions = ForestAdminAgent::Services::Permissions.new(context.caller)
+        context
       end
 
-      def format_attributes(args)
+      def format_attributes(args, collection)
         record = args[:params][:data][:attributes] || {}
 
         args[:params][:data][:relationships]&.map do |field, value|
-          schema = @collection.schema[:fields][field]
+          schema = collection.schema[:fields][field]
 
-          record[schema.foreign_key] = value['data']['id'] if schema.type == 'ManyToOne'
+          record[schema.foreign_key] = value.dig('data', 'id') if schema.type == 'ManyToOne'
         end
 
         record || {}

data/lib/forest_admin_agent/routes/abstract_related_route.rb

@@ -2,14 +2,16 @@ module ForestAdminAgent
   module Routes
     class AbstractRelatedRoute < AbstractAuthenticatedRoute
       def build(args = {})
-        super
+        context = super
 
-        relation = @collection.schema[:fields][args[:params]['relation_name']]
-        @child_collection = if relation.type == 'PolymorphicManyToOne'
-                              @datasource.get_collection(args[:params]['data']['type'])
-                            else
-                              @datasource.get_collection(relation.foreign_collection)
-                            end
+        relation = context.collection.schema[:fields][args[:params]['relation_name']]
+        context.child_collection = if relation.type == 'PolymorphicManyToOne'
+                                     context.datasource.get_collection(args[:params]['data']['type'])
+                                   else
+                                     context.datasource.get_collection(relation.foreign_collection)
+                                   end
+
+        context
       end
     end
   end

data/lib/forest_admin_agent/routes/abstract_route.rb

@@ -7,10 +7,14 @@ module ForestAdminAgent
       end
 
       def build(args)
-        @datasource = ForestAdminAgent::Facades::Container.datasource
-        return unless args[:params]['collection_name']
+        context = RequestContext.new
+        context.datasource = ForestAdminAgent::Facades::Container.datasource
 
-        @collection = @datasource.get_collection(args[:params]['collection_name'])
+        if args[:params]['collection_name']
+          context.collection = context.datasource.get_collection(args[:params]['collection_name'])
+        end
+
+        context
       end
 
       def routes

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

@@ -14,14 +14,14 @@ module ForestAdminAgent
 
         def initialize(collection, action)
           @action_name = action
-          @collection = collection
+          @route_collection = collection
           super()
         end
 
         def setup_routes
-          action_index = @collection.schema[:actions].keys.index(@action_name)
+          action_index = @route_collection.schema[:actions].keys.index(@action_name)
           slug = ForestAdminAgent::Utils::Schema::GeneratorAction.get_action_slug(@action_name)
-          route_name = "forest_action_#{@collection.name}_#{action_index}_#{slug}"
+          route_name = "forest_action_#{@route_collection.name}_#{action_index}_#{slug}"
           path = "/_actions/:collection_name/#{action_index}/#{slug}"
 
           add_route(route_name, 'post', path, proc { |args| handle_request(args) })
@@ -47,12 +47,12 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
+          context = build(args)
           args = middleware_custom_action_approval_request_data(args)
-          filter_for_caller = get_record_selection(args)
-          get_record_selection(args, include_user_scope: false)
+          filter_for_caller = get_record_selection(args, context)
+          get_record_selection(args, context, include_user_scope: false)
 
-          @permissions.can_smart_action?(args, @collection, filter_for_caller)
+          context.permissions.can_smart_action?(args, context.collection, filter_for_caller)
 
           raw_data = args.dig(:params, :data, :attributes, :values)
 
@@ -60,8 +60,8 @@ module ForestAdminAgent
           # better send invalid data to the getForm() customer handler than to the execute() one.
           unsafe_data = Schema::ForestValueConverter.make_form_data_unsafe(raw_data)
 
-          fields = @collection.get_form(
-            @caller,
+          fields = context.collection.get_form(
+            context.caller,
             @action_name,
             unsafe_data,
             filter_for_caller,
@@ -70,24 +70,27 @@ module ForestAdminAgent
 
           # Now that we have the field list, we can parse the data again.
           data = Schema::ForestValueConverter.make_form_data(
-            @datasource,
+            context.datasource,
             raw_data,
             fields.reject { |field| field.type == 'Layout' }
           )
 
-          { content: @collection.execute(@caller, @action_name, data, filter_for_caller) }
+          { content: context.collection.execute(context.caller, @action_name, data, filter_for_caller) }
         end
 
         def handle_hook_request(args = {})
-          build(args)
+          context = build(args)
           forest_fields = args.dig(:params, :data, :attributes, :fields)
-          data = (Schema::ForestValueConverter.make_form_data_from_fields(@datasource, forest_fields) if forest_fields)
-          filter = get_record_selection(args)
+          data = (if forest_fields
+                    Schema::ForestValueConverter.make_form_data_from_fields(context.datasource,
+                                                                            forest_fields)
+                  end)
+          filter = get_record_selection(args, context)
           search_values = {}
           forest_fields&.each { |field| search_values[field['field']] = field['searchValue'] }
 
-          form = @collection.get_form(
-            @caller,
+          form = context.collection.get_form(
+            context.caller,
             @action_name,
             data,
             filter,
@@ -102,7 +105,9 @@ module ForestAdminAgent
 
           {
             content: {
-              fields: form_elements[:fields].map { |f| Schema::GeneratorAction.build_field_schema(@datasource, f) },
+              fields: form_elements[:fields].map do |f|
+                Schema::GeneratorAction.build_field_schema(context.datasource, f)
+              end,
               layout: Schema::GeneratorAction.build_layout(form_elements[:layout])
             }
           }
@@ -129,26 +134,26 @@ module ForestAdminAgent
           )[0])
         end
 
-        def get_record_selection(args, include_user_scope: true)
+        def get_record_selection(args, context, include_user_scope: true)
           attributes = args.dig(:params, :data, :attributes)
 
           # Match user filter + search + scope? + segment
-          scope = include_user_scope ? @permissions.get_scope(@collection) : nil
+          scope = include_user_scope ? context.permissions.get_scope(context.collection) : nil
           filter = Filter.new(
             condition_tree: ConditionTreeFactory.intersect(
               [
                 scope,
                 ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(
-                  @collection, args
+                  context.collection, args
                 )
               ]
             )
           )
 
           # Restrict the filter to the selected records for single or bulk actions
-          if @collection.schema[:actions][@action_name].scope != Types::ActionScope::GLOBAL
-            selection_ids = Utils::Id.parse_selection_ids(@collection, args[:params])
-            selected_ids = ConditionTreeFactory.match_ids(@collection, selection_ids[:ids])
+          if context.collection.schema[:actions][@action_name].scope != Types::ActionScope::GLOBAL
+            selection_ids = Utils::Id.parse_selection_ids(context.collection, args[:params])
+            selected_ids = ConditionTreeFactory.match_ids(context.collection, selection_ids[:ids])
             selected_ids = selected_ids.inverse if selection_ids[:are_excluded]
             filter = filter.override(
               condition_tree: ConditionTreeFactory.intersect([filter.condition_tree, selected_ids])
@@ -158,10 +163,11 @@ module ForestAdminAgent
           # Restrict the filter further for the "related data" page
           unless attributes[:parent_association_name].nil?
             relation = attributes[:parent_association_name]
-            parent = @datasource.get_collection(attributes[:parent_collection_name])
+            parent = context.datasource.get_collection(attributes[:parent_collection_name])
             parent_primary_key_values = Utils::Id.unpack_id(parent, attributes[:parent_collection_id])
 
-            filter = FilterFactory.make_foreign_filter(parent, parent_primary_key_values, relation, @caller, filter)
+            filter = FilterFactory.make_foreign_filter(parent, parent_primary_key_values, relation, context.caller,
+                                                       filter)
           end
 
           filter

data/lib/forest_admin_agent/routes/capabilities/collections.rb

@@ -2,7 +2,7 @@ require 'json'
 module ForestAdminAgent
   module Routes
     module Capabilities
-      class Collections < AbstractAuthenticatedRoute
+      class Collections < AbstractRoute
         include ForestAdminDatasourceToolkit::Schema
 
         def setup_routes
@@ -15,13 +15,13 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          @datasource = ForestAdminAgent::Facades::Container.datasource
+          datasource = ForestAdminAgent::Facades::Container.datasource
           collections = args[:params]['collectionNames'] || []
 
-          connections = @datasource.live_query_connections.keys.map { |connection_name| { name: connection_name } }
+          connections = datasource.live_query_connections.keys.map { |connection_name| { name: connection_name } }
 
           result = collections.map do |collection_name|
-            collection = @datasource.get_collection(collection_name)
+            collection = datasource.get_collection(collection_name)
             {
               name: collection.name,
               fields: collection.schema[:fields].select { |_, field| field.is_a?(ColumnSchema) }.map do |name, field|

data/lib/forest_admin_agent/routes/charts/api_chart_collection.rb

@@ -9,14 +9,14 @@ module ForestAdminAgent
 
         def initialize(collection, chart_name)
           @chart_name = chart_name
-          @collection = collection
+          @route_collection = collection
 
           super()
         end
 
         def setup_routes
           # Mount both GET and POST, respectively for smart and api charts.
-          collection_name = @collection.name
+          collection_name = @route_collection.name
           slug = @chart_name.parameterize
 
           add_route(
@@ -44,25 +44,25 @@ module ForestAdminAgent
         end
 
         def handle_api_chart(args)
-          build(args)
+          context = build(args)
           {
             content: Serializer::ForestChartSerializer.serialize(
-              @collection.render_chart(
-                @caller,
+              context.collection.render_chart(
+                context.caller,
                 @chart_name,
-                Id.unpack_id(@collection, args[:params]['record_id'])
+                Id.unpack_id(context.collection, args[:params]['record_id'])
               )
             )
           }
         end
 
         def handle_smart_chart(args)
-          build(args)
+          context = build(args)
           {
-            content: @collection.render_chart(
-              @caller,
+            content: context.collection.render_chart(
+              context.caller,
               @chart_name,
-              Id.unpack_id(@collection, args[:params]['record_id'])
+              Id.unpack_id(context.collection, args[:params]['record_id'])
             )
           }
         end

data/lib/forest_admin_agent/routes/charts/api_chart_datasource.rb

@@ -7,7 +7,6 @@ module ForestAdminAgent
       class ApiChartDatasource < AbstractAuthenticatedRoute
         def initialize(chart_name)
           @chart_name = chart_name
-          @datasource = ForestAdminAgent::Facades::Container.datasource
 
           super()
         end
@@ -38,12 +37,13 @@ module ForestAdminAgent
         end
 
         def handle_api_chart(args = {})
-          @caller = Utils::QueryStringParser.parse_caller(args)
+          caller = Utils::QueryStringParser.parse_caller(args)
+          datasource = ForestAdminAgent::Facades::Container.datasource
 
           {
             content: Serializer::ForestChartSerializer.serialize(
-              @datasource.render_chart(
-                @caller,
+              datasource.render_chart(
+                caller,
                 @chart_name
               )
             )
@@ -51,11 +51,12 @@ module ForestAdminAgent
         end
 
         def handle_smart_chart(args = {})
-          @caller = Utils::QueryStringParser.parse_caller(args)
+          caller = Utils::QueryStringParser.parse_caller(args)
+          datasource = ForestAdminAgent::Facades::Container.datasource
 
           {
-            content: @datasource.render_chart(
-              @caller,
+            content: datasource.render_chart(
+              caller,
               @chart_name
             )
           }

data/lib/forest_admin_agent/routes/charts/charts.rb

@@ -11,8 +11,6 @@ module ForestAdminAgent
         include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
         include ForestAdminDatasourceToolkit::Components::Charts
 
-        attr_reader :filter
-
         FORMAT = {
           Day: '%d/%m/%Y',
           Week: 'W%V-%G',
@@ -28,97 +26,97 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can_chart?(args[:params])
-          @args = args
-          self.type = args[:params][:type]
-          @filter = Filter.new(
+          context = build(args)
+          context.permissions.can_chart?(args[:params])
+          type = validate_and_get_type(args[:params][:type])
+          filter = Filter.new(
             condition_tree: ConditionTreeFactory.intersect(
               [
-                @permissions.get_scope(@collection),
+                context.permissions.get_scope(context.collection),
                 ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(
-                  @collection, args
+                  context.collection, args
                 )
               ]
             )
           )
 
-          inject_context_variables
+          filter = inject_context_variables(filter, context, args)
 
-          { content: Serializer::ForestChartSerializer.serialize(send(:"make_#{@type}")) }
+          { content: Serializer::ForestChartSerializer.serialize(send(:"make_#{type}", context, filter, args)) }
         end
 
         private
 
-        def type=(type)
+        def validate_and_get_type(type)
           chart_types = %w[Value Objective Pie Line Leaderboard]
           unless chart_types.include?(type)
             raise ForestAdminDatasourceToolkit::Exceptions::ForestException, "Invalid Chart type #{type}"
           end
 
-          @type = type.downcase
+          type.downcase
         end
 
-        def inject_context_variables
-          user = @permissions.get_user_data(@caller.id)
-          team = @permissions.get_team(@caller.rendering_id)
+        def inject_context_variables(filter, context, args)
+          user = context.permissions.get_user_data(context.caller.id)
+          team = context.permissions.get_team(context.caller.rendering_id)
 
           context_variables = ForestAdminAgent::Utils::ContextVariables.new(team, user,
-                                                                            @args[:params][:contextVariables])
-          return unless @args[:params][:filter]
+                                                                            args[:params][:contextVariables])
+          return filter unless args[:params][:filter]
 
-          @filter = @filter.override(condition_tree: ContextVariablesInjector.inject_context_in_filter(
-            @filter.condition_tree, context_variables
+          filter.override(condition_tree: ContextVariablesInjector.inject_context_in_filter(
+            filter.condition_tree, context_variables
           ))
         end
 
-        def make_value
-          value = compute_value(@filter)
+        def make_value(context, filter, args)
+          value = compute_value(context, filter, args)
           previous_value = nil
-          is_and_aggregator = @filter.condition_tree&.try(:aggregator) == 'And'
-          with_count_previous = @filter.condition_tree&.some_leaf(&:use_interval_operator)
+          is_and_aggregator = filter.condition_tree&.try(:aggregator) == 'And'
+          with_count_previous = filter.condition_tree&.some_leaf(&:use_interval_operator)
 
           if with_count_previous && !is_and_aggregator
-            previous_value = compute_value(FilterFactory.get_previous_period_filter(@filter, @caller.timezone))
+            previous_filter = FilterFactory.get_previous_period_filter(filter, context.caller.timezone)
+            previous_value = compute_value(context, previous_filter, args)
           end
 
           ValueChart.new(value, previous_value).serialize
         end
 
-        def make_objective
-          ObjectiveChart.new(compute_value(@filter)).serialize
+        def make_objective(context, filter, args)
+          ObjectiveChart.new(compute_value(context, filter, args)).serialize
         end
 
-        def make_pie
-          group_field = @args[:params][:groupByFieldName]
+        def make_pie(context, filter, args)
+          group_field = args[:params][:groupByFieldName]
           aggregation = Aggregation.new(
-            operation: @args[:params][:aggregator],
-            field: @args[:params][:aggregateFieldName],
+            operation: args[:params][:aggregator],
+            field: args[:params][:aggregateFieldName],
             groups: group_field ? [{ field: group_field }] : []
           )
 
-          result = @collection.aggregate(@caller, @filter, aggregation)
+          result = context.collection.aggregate(context.caller, filter, aggregation)
 
           PieChart.new(result.map { |row| { key: row['group'][group_field], value: row['value'] } }).serialize
         end
 
-        def make_line
-          group_by_field_name = @args[:params][:groupByFieldName]
-          time_range = @args[:params][:timeRange]
-          filter_only_with_values = @filter.override(
+        def make_line(context, filter, args)
+          group_by_field_name = args[:params][:groupByFieldName]
+          time_range = args[:params][:timeRange]
+          filter_only_with_values = filter.override(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect(
               [
-                @filter.condition_tree,
+                filter.condition_tree,
                 ConditionTree::Nodes::ConditionTreeLeaf.new(group_by_field_name, ConditionTree::Operators::PRESENT)
               ]
             )
           )
-          rows = @collection.aggregate(
-            @caller,
+          rows = context.collection.aggregate(
+            context.caller,
             filter_only_with_values,
             Aggregation.new(
-              operation: @args[:params][:aggregator],
-              field: @args[:params][:aggregateFieldName],
+              operation: args[:params][:aggregator],
+              field: args[:params][:aggregateFieldName],
               groups: [{ field: group_by_field_name, operation: time_range }]
             )
           )
@@ -140,51 +138,51 @@ module ForestAdminAgent
           LineChart.new(result).serialize
         end
 
-        def make_leaderboard
-          field = @collection.schema[:fields][@args[:params][:relationshipFieldName]]
+        def make_leaderboard(context, filter, args)
+          field = context.collection.schema[:fields][args[:params][:relationshipFieldName]]
 
           if field && field.type == 'OneToMany'
             inverse = ForestAdminDatasourceToolkit::Utils::Collection.get_inverse_relation(
-              @collection,
-              @args[:params][:relationshipFieldName]
+              context.collection,
+              args[:params][:relationshipFieldName]
             )
             if inverse
               collection = field.foreign_collection
-              filter = @filter.nest(inverse)
+              leaderboard_filter = filter.nest(inverse)
               aggregation = Aggregation.new(
-                operation: @args[:params][:aggregator],
-                field: @args[:params][:aggregateFieldName],
-                groups: [{ field: "#{inverse}:#{@args[:params][:labelFieldName]}" }]
+                operation: args[:params][:aggregator],
+                field: args[:params][:aggregateFieldName],
+                groups: [{ field: "#{inverse}:#{args[:params][:labelFieldName]}" }]
               )
             end
           end
 
           if field && field.type == 'ManyToMany'
             origin = ForestAdminDatasourceToolkit::Utils::Collection.get_through_origin(
-              @collection,
-              @args[:params][:relationshipFieldName]
+              context.collection,
+              args[:params][:relationshipFieldName]
             )
             target = ForestAdminDatasourceToolkit::Utils::Collection.get_through_target(
-              @collection,
-              @args[:params][:relationshipFieldName]
+              context.collection,
+              args[:params][:relationshipFieldName]
             )
             if origin && target
               collection = field.through_collection
-              filter = @filter.nest(origin)
+              leaderboard_filter = filter.nest(origin)
               aggregation = Aggregation.new(
-                operation: @args[:params][:aggregator],
-                field: @args[:params][:aggregateFieldName] ? "#{target}:#{@args[:params][:aggregateFieldName]}" : nil,
-                groups: [{ field: "#{origin}:#{@args[:params][:labelFieldName]}" }]
+                operation: args[:params][:aggregator],
+                field: args[:params][:aggregateFieldName] ? "#{target}:#{args[:params][:aggregateFieldName]}" : nil,
+                groups: [{ field: "#{origin}:#{args[:params][:labelFieldName]}" }]
               )
             end
           end
 
-          if collection && filter && aggregation
-            rows = @datasource.get_collection(collection).aggregate(
-              @caller,
-              filter,
+          if collection && leaderboard_filter && aggregation
+            rows = context.datasource.get_collection(collection).aggregate(
+              context.caller,
+              leaderboard_filter,
               aggregation,
-              @args[:params][:limit]
+              args[:params][:limit]
             )
 
             result = rows.map do |row|
@@ -201,10 +199,10 @@ module ForestAdminAgent
                 'Failed to generate leaderboard chart: parameters do not match pre-requisites'
         end
 
-        def compute_value(filter)
-          aggregation = Aggregation.new(operation: @args[:params][:aggregator],
-                                        field: @args[:params][:aggregateFieldName])
-          result = @collection.aggregate(@caller, filter, aggregation)
+        def compute_value(context, filter, args)
+          aggregation = Aggregation.new(operation: args[:params][:aggregator],
+                                        field: args[:params][:aggregateFieldName])
+          result = context.collection.aggregate(context.caller, filter, aggregation)
 
           result[0]['value'] || 0
         end

data/lib/forest_admin_agent/routes/request_context.rb

@@ -0,0 +1,17 @@
+module ForestAdminAgent
+  module Routes
+    # RequestContext holds request-specific data that should not be shared between concurrent requests.
+    # This prevents race conditions when route instances are reused across multiple requests.
+    class RequestContext
+      attr_accessor :datasource, :collection, :child_collection, :caller, :permissions
+
+      def initialize(datasource: nil, collection: nil, child_collection: nil, caller: nil, permissions: nil)
+        @datasource = datasource
+        @collection = collection
+        @child_collection = child_collection
+        @caller = caller
+        @permissions = permissions
+      end
+    end
+  end
+end

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

@@ -15,24 +15,24 @@ module ForestAdminAgent
         end
 
         def handle_request(args = {})
-          build(args)
-          @permissions.can?(:browse, @collection)
+          context = build(args)
+          context.permissions.can?(:browse, context.collection)
 
-          if @collection.is_countable?
+          if context.collection.is_countable?
             filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
               condition_tree: ConditionTreeFactory.intersect(
                 [
-                  @permissions.get_scope(@collection),
-                  parse_query_segment(@collection, args, @permissions, @caller),
-                  ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(@collection, args)
+                  context.permissions.get_scope(context.collection),
+                  parse_query_segment(context.collection, args, context.permissions, context.caller),
+                  ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(context.collection, args)
                 ]
               ),
-              search: QueryStringParser.parse_search(@collection, args),
+              search: QueryStringParser.parse_search(context.collection, args),
               search_extended: QueryStringParser.parse_search_extended(args),
-              segment: QueryStringParser.parse_segment(@collection, args)
+              segment: QueryStringParser.parse_segment(context.collection, args)
             )
             aggregation = ForestAdminDatasourceToolkit::Components::Query::Aggregation.new(operation: 'Count')
-            result = @collection.aggregate(@caller, filter, aggregation)
+            result = context.collection.aggregate(context.caller, filter, aggregation)
 
             return {
               name: args[:params]['collection_name'],