forest_admin_agent 1.9.1 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d85148dc0247c3d0d74c458344980576ec7aa14772a8015d237b2b63cfdd88c3
-  data.tar.gz: ba8f07da138797ad91f931ab56db345dd37d3f8ca13d95655b28af2180594b8b
+  metadata.gz: d4ece5f90c8cf5ecc42aeac33df998c280e581af076edd9fde12f34860f10737
+  data.tar.gz: 7dff9b95291a1add4102376a9e609a1e97c1a010c1f5a2292921de2e09cbf31d
 SHA512:
-  metadata.gz: e4c49cc7ef501eeb34283106e9f21e12b992570afb17974ba30581d7076749d2d647e5bc539fc22145d75deaf693f547a7c1e2441285967244479cd40c44ffad
-  data.tar.gz: 4468d234313447da09cbfb88907db657bc0ba51f238c5fa18c43aa45b274d59eb0593507838c1cd78c387a1ae6ec158d83e3f524823889ad13fc22c6c85af568
+  metadata.gz: 19b5b40cfc2492918a284f6409a79be709aea4d245e3673f9b811543327540be68cc850c2483cd1773672df7df62960fe450d702b9cb5a6caebdee01ecc0f687
+  data.tar.gz: b4fbf11c6492f9d3e2d75ebf6ec0ce08a850ec06fdcf7596c9abbe2cc6929d87fa5b70721e452acbd3015b9ebdd90a107e63c6573aed2d479c5980dfd03d250f

data/lib/forest_admin_agent/http/router.rb

@@ -20,6 +20,7 @@ module ForestAdminAgent
           Resources::Show.new.routes,
           Resources::Store.new.routes,
           Resources::Update.new.routes,
+          Resources::UpdateField.new.routes,
           Resources::Related::CsvRelated.new.routes,
           Resources::Related::ListRelated.new.routes,
           Resources::Related::CountRelated.new.routes,

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

@@ -32,20 +32,41 @@ module ForestAdminAgent
                 )
               ]
             ),
-            page: QueryStringParser.parse_export_pagination(Facades::Container.config_from_cache[:limit_export_size]),
             search: QueryStringParser.parse_search(@collection, args),
-            search_extended: QueryStringParser.parse_search_extended(args)
+            search_extended: QueryStringParser.parse_search_extended(args),
+            sort: QueryStringParser.parse_sort(@collection, args),
+            segment: QueryStringParser.parse_segment(@collection, args)
           )
           projection = QueryStringParser.parse_projection(@collection, args)
-          records = @collection.list(@caller, filter, projection)
-          filename = args[:params][:filename] || "#{args[:params]["collection_name"]}.csv"
+          filename = args[:params][:filename] || args[:params]['collection_name']
           filename += '.csv' unless /\.csv$/i.match?(filename)
+          header = args[:params][:header]
+
+          # Generate timestamp for filename
+          now = Time.now.strftime('%Y%m%d_%H%M%S')
+          filename_with_timestamp = filename.gsub('.csv', "_export_#{now}.csv")
+
+          # Return streaming enumerator instead of full CSV string
+          list_records = ->(batch_filter) { @collection.list(@caller, batch_filter, projection) }
 
           {
             content: {
-              export: CsvGenerator.generate(records, projection)
+              type: 'Stream',
+              enumerator: Utils::CsvGeneratorStream.stream(
+                header,
+                filter,
+                projection,
+                list_records,
+                Facades::Container.config_from_cache[:limit_export_size]
+              ),
+              headers: {
+                'Content-Type' => 'text/csv; charset=utf-8',
+                'Content-Disposition' => "attachment; filename=\"#{filename_with_timestamp}\"",
+                'Cache-Control' => 'no-cache',
+                'X-Accel-Buffering' => 'no'
+              }
             },
-            filename: filename
+            status: 200
           }
         end
       end

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

@@ -30,28 +30,51 @@ module ForestAdminAgent
                   @permissions.get_scope(@collection),
                   ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(@child_collection, args)
                 ]
-              ),
-              page: QueryStringParser.parse_export_pagination(Facades::Container.config_from_cache[:limit_export_size])
+              )
             )
             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)
-            records = Collection.list_relation(
-              @collection,
-              id,
-              args[:params]['relation_name'],
-              @caller,
-              filter,
-              projection
-            )
+            relation_name = args[:params]['relation_name']
+
+            # Generate timestamp for filename
+            now = Time.now.strftime('%Y%m%d_%H%M%S')
+            collection_name = args.dig(:params, 'collection_name')
+            header = args.dig(:params, 'header')
+            filename_with_timestamp = "#{collection_name}_#{relation_name}_export_#{now}.csv"
 
-            filename = args[:params][:filename] || "#{args[:params]["relation_name"]}.csv"
-            filename += '.csv' unless /\.csv$/i.match?(filename)
+            # Create a callable to fetch related records
+            list_records = lambda do |batch_filter|
+              ForestAdminDatasourceToolkit::Utils::Collection.list_relation(
+                @collection,
+                id,
+                relation_name,
+                @caller,
+                batch_filter,
+                projection
+              )
+            end
 
+            # For related exports, use list_relation to fetch records
             {
               content: {
-                export: CsvGenerator.generate(records, projection)
+                type: 'Stream',
+                enumerator: ForestAdminAgent::Utils::CsvGeneratorStream.stream(
+                  header,
+                  filter,
+                  projection,
+                  list_records,
+                  Facades::Container.config_from_cache[:limit_export_size]
+                ),
+                headers: {
+                  'Content-Type' => 'text/csv; charset=utf-8',
+                  'Content-Disposition' => "attachment; filename=\"#{filename_with_timestamp}\"",
+                  'Cache-Control' => 'no-cache',
+                  'X-Accel-Buffering' => 'no'
+                }
               },
-              filename: filename
+              status: 200
             }
           end
         end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      class UpdateField < AbstractAuthenticatedRoute
+        include ForestAdminAgent::Builder
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Validations
+        include ForestAdminDatasourceToolkit::Schema
+
+        def setup_routes
+          add_route(
+            'forest_update_field',
+            'put',
+            '/:collection_name/:id/relationships/:field_name/:index',
+            ->(args) { handle_request(args) }
+          )
+
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+
+          record_id = Utils::Id.unpack_id(@collection, args[:params]['id'], with_key: true)
+          field_name = args[:params]['field_name']
+          array_index = parse_index(args[:params]['index'])
+
+          @permissions.can?(:edit, @collection)
+
+          field_schema = @collection.schema[:fields][field_name]
+          validate_array_field!(field_schema, field_name)
+
+          record = fetch_record(record_id)
+
+          array = record[field_name]
+          validate_array_value!(array, field_name, array_index)
+
+          new_value = parse_value_from_body(args[:params], field_schema)
+
+          updated_array = array.dup
+          updated_array[array_index] = new_value
+
+          scope = @permissions.get_scope(@collection)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [record_id])
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+            condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
+          )
+          @collection.update(@caller, filter, { field_name => updated_array })
+
+          records = @collection.list(@caller, filter, ProjectionFactory.all(@collection))
+
+          {
+            name: args[:params]['collection_name'],
+            content: JSONAPI::Serializer.serialize(
+              records[0],
+              is_collection: false,
+              class_name: @collection.name,
+              serializer: Serializer::ForestSerializer
+            )
+          }
+        end
+
+        private
+
+        def parse_index(index_param)
+          index = Integer(index_param)
+          raise Http::Exceptions::ValidationError, 'Index must be non-negative' if index.negative?
+
+          index
+        rescue ArgumentError
+          raise Http::Exceptions::ValidationError, "Invalid index: #{index_param}"
+        end
+
+        def validate_array_field!(field_schema, field_name)
+          FieldValidator.validate(@collection, field_name)
+          return if field_schema.column_type.to_s.start_with?('[')
+
+          raise Http::Exceptions::ValidationError,
+                "Field '#{field_name}' is not an array (type: #{field_schema.column_type})"
+        rescue ForestAdminDatasourceToolkit::Exceptions::ValidationError => e
+          raise Http::Exceptions::NotFoundError, e.message if e.message.include?('not found')
+
+          raise Http::Exceptions::ValidationError, e.message
+        end
+
+        def fetch_record(record_id)
+          scope = @permissions.get_scope(@collection)
+          condition_tree = ConditionTree::ConditionTreeFactory.match_records(@collection, [record_id])
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+            condition_tree: ConditionTree::ConditionTreeFactory.intersect([condition_tree, scope])
+          )
+          records = @collection.list(@caller, filter, ProjectionFactory.all(@collection))
+
+          raise Http::Exceptions::NotFoundError, 'Record not found' unless records&.any?
+
+          records[0]
+        end
+
+        def validate_array_value!(array, field_name, array_index)
+          unless array.is_a?(Array)
+            raise Http::Exceptions::UnprocessableError,
+                  "Field '#{field_name}' value is not an array (got: #{array.class})"
+          end
+
+          return unless array_index >= array.length
+
+          raise Http::Exceptions::ValidationError,
+                "Index #{array_index} out of bounds for array of length #{array.length}"
+        end
+
+        def parse_value_from_body(params, field_schema)
+          body = params[:data] || {}
+          value = body.dig(:attributes, 'value') || body.dig(:attributes, :value)
+
+          coerce_value(value, field_schema.column_type)
+        end
+
+        def coerce_value(value, column_type)
+          return value unless column_type.to_s.start_with?('[') && column_type.to_s.end_with?(']')
+
+          element_type = column_type.to_s[1..-2]
+
+          if element_type == 'Number' && value.is_a?(String)
+            begin
+              return Float(value)
+            rescue ArgumentError
+              raise Http::Exceptions::ValidationError, "Cannot coerce '#{value}' to Number - wrong type"
+            end
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/utils/csv_generator_stream.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module ForestAdminAgent
+  module Utils
+    class CsvGeneratorStream
+      CHUNK_SIZE = 1000
+
+      # @param header [Array<String>] CSV header fields
+      # @param filter [ForestAdminDatasourceToolkit::Components::Query::Filter] Query filter
+      # @param projection [ForestAdminDatasourceToolkit::Components::Query::Projection] Fields to include
+      # @param list_records [Proc] A callable that fetches records: ->(batch_filter) { ... }
+      # @param limit_export_size [Integer, nil] Maximum number of records to export
+      # @return [Enumerator] Lazy enumerator that yields CSV rows
+      def self.stream(header, filter, projection, list_records, limit_export_size = nil)
+        Enumerator.new do |yielder|
+          # Yield header row first (client receives immediately)
+          header_array = parse_header(header, projection)
+          yielder << "#{header_array.join(",")}\n"
+
+          offset = 0
+
+          loop do
+            # Fetch batch of records
+            batch_filter = filter.override(
+              page: ForestAdminDatasourceToolkit::Components::Query::Page.new(offset: offset, limit: CHUNK_SIZE)
+            )
+            records = list_records.call(batch_filter)
+
+            # Break if no more records
+            break if records.empty?
+
+            # Convert each record to CSV row and yield immediately
+            records.each do |record|
+              yielder << generate_row(record, projection)
+            end
+
+            # Update offset
+            offset += CHUNK_SIZE
+
+            # Check if we've reached the export limit
+            break if limit_export_size && offset >= limit_export_size
+
+            # Check if this was a partial batch (last batch)
+            break if records.length < CHUNK_SIZE
+
+            # Periodic garbage collection to prevent memory creep
+            GC.start(full_mark: false) if (offset % 10_000).zero?
+          end
+        rescue IOError, Errno::EPIPE => e
+          # Client disconnected - clean up gracefully
+          Facades::Container.logger&.log(
+            'Info',
+            "CSV export interrupted at offset #{offset}: #{e.message}"
+          )
+        end
+      end
+
+      # Parse header parameter into an array
+      # @param header [String, Array, nil] Header as JSON string, array, or nil
+      # @param projection [Projection] Field projection (fallback if header is invalid)
+      # @return [Array<String>] Header fields
+      def self.parse_header(header, projection)
+        case header
+        when Array
+          header
+        when String
+          return projection.to_a if header.empty?
+
+          JSON.parse(header)
+        else
+          projection.to_a
+        end
+      rescue JSON::ParserError
+        # Fallback to projection if JSON parsing fails
+        projection.to_a
+      end
+
+      # Generate CSV row from record data
+      # @param record [Hash] Record data
+      # @param projection [Projection] Field projection
+      # @return [String] CSV data line
+      def self.generate_row(record, projection)
+        values = projection.map do |field|
+          value = ForestAdminDatasourceToolkit::Utils::Record.field_value(record, field)
+          format_value(value)
+        end
+        CSV.generate_line(values)
+      end
+
+      # Format individual value for CSV output
+      # @param value [Object] Value to format
+      # @return [String] Formatted value
+      def self.format_value(value)
+        case value
+        when nil
+          ''
+        when Array, Hash
+          value.to_json
+        when Date, DateTime, Time
+          value.respond_to?(:iso8601) ? value.iso8601 : value.to_s
+        else
+          value.to_s
+        end
+      end
+
+      private_class_method :parse_header, :generate_row, :format_value
+    end
+  end
+end

data/lib/forest_admin_agent/utils/id.rb

@@ -27,7 +27,7 @@ module ForestAdminAgent
           field = collection.schema[:fields][pk_name]
           value = primary_key_values[index]
           casted_value = field.column_type == 'Number' ? value.to_i : value
-          ForestAdminDatasourceToolkit::Validations::FieldValidator.validate_value(value, field, casted_value)
+          ForestAdminDatasourceToolkit::Validations::FieldValidator.validate_value(pk_name, field, casted_value)
 
           [pk_name, casted_value]
         end.to_h

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

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.9.1"
+  VERSION = "1.11.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.11.0
 platform: ruby
 authors:
 - Matthieu
@@ -264,6 +264,7 @@ files:
 - lib/forest_admin_agent/routes/resources/show.rb
 - lib/forest_admin_agent/routes/resources/store.rb
 - lib/forest_admin_agent/routes/resources/update.rb
+- lib/forest_admin_agent/routes/resources/update_field.rb
 - lib/forest_admin_agent/routes/security/authentication.rb
 - lib/forest_admin_agent/routes/security/scope_invalidation.rb
 - lib/forest_admin_agent/routes/system/health_check.rb
@@ -280,6 +281,7 @@ files:
 - lib/forest_admin_agent/utils/context_variables.rb
 - lib/forest_admin_agent/utils/context_variables_injector.rb
 - lib/forest_admin_agent/utils/csv_generator.rb
+- lib/forest_admin_agent/utils/csv_generator_stream.rb
 - lib/forest_admin_agent/utils/error_messages.rb
 - lib/forest_admin_agent/utils/id.rb
 - lib/forest_admin_agent/utils/query_string_parser.rb