forest_admin_agent 1.0.0.pre.beta.48 → 1.0.0.pre.beta.49

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40e4df2d99083f936e9cf9a4693f20d69cc6d3b2b86d8ef8c66abafdbd554d2b
-  data.tar.gz: 732d5c6d7c20f67558d609c1a8e28d834bbb1b01bd0880988721409e4bc564d7
+  metadata.gz: 23ea6e5c071b956705a5f6fb880be2a837c07714c33117e20304ad07921ab7bf
+  data.tar.gz: 7637f501d7dcf319eedace4183e2b40675c71bd8faa5fc06e62a5a72f91c3580
 SHA512:
-  metadata.gz: '009c1d66c244400c79b66dc66fa1acd0bcdd80de1c7cea811050352bdc1dc6ec494025a732f2a52b9368319db782da1fb720aa0cef1bc2d427c98a145da5614d'
-  data.tar.gz: a349fd075afbc6ed33fd44aba00dcd71f79b2d8ec767b4877f7756c41540368f25827a2501b825b92af08e7db9ce426a8009972a0af44f5a2334acc75fc5ac29
+  metadata.gz: 0656cfcadb4df52020d45f816f49332337686c77ec5d1996448aa67f246be319aa8d1a43860ce63c558be15106751c249aff61fb2f9d27303c934b99bbe4d4a1
+  data.tar.gz: b9ac0d65d0dc13e3a5c011b22ccef0e5208da775087d3b95fbcc17ec7cc4427d78b5ad4e50c4d7b43b10e24750dc610928806dcde69abacf43e7a41f230411f7

data/lib/forest_admin_agent/builder/agent_factory.rb

@@ -34,6 +34,8 @@ module ForestAdminAgent
 
       def customize_collection(name, &handle)
         @customizer.customize_collection(name, handle)
+
+        self
       end
 
       def build
@@ -74,6 +76,14 @@ module ForestAdminAgent
         return unless @has_env_secret
 
         cache = @container.resolve(:cache)
+        @options[:customize_error_message] = @options[:customize_error_message]
+                                             &.source
+                                             &.strip
+                                             &.delete_prefix('config.customize_error_message =')
+                                             &.strip
+
+        @options[:logger] = @options[:logger]&.source&.strip&.delete_prefix('config.logger =')&.strip
+
         cache.set('config', @options.to_h)
       end
 

data/lib/forest_admin_agent/facades/container.rb

@@ -6,7 +6,9 @@ module ForestAdminAgent
       end
 
       def self.datasource
-        instance.resolve(:datasource)
+        instance.resolve(:datasource) do
+          ForestAdminDatasourceToolkit::Datasource.new
+        end
       end
 
       def self.logger

data/lib/forest_admin_agent/http/Exceptions/authentication_open_id_client.rb

@@ -2,12 +2,12 @@ module ForestAdminAgent
   module Http
     module Exceptions
       class AuthenticationOpenIdClient < HttpException
-        attr_reader :error, :error_description, :state
+        attr_reader :error, :message, :state
 
         def initialize(error, error_description, state)
           super(error, 401, error_description)
           @error = error
-          @error_description = error_description
+          @message = error_description
           @state = state
         end
       end

data/lib/forest_admin_agent/http/error_handling.rb

@@ -0,0 +1,18 @@
+module ForestAdminAgent
+  module Http
+    module ErrorHandling
+      def get_error_message(error)
+        if error.respond_to?(:ancestors) && error.ancestors.include?(ForestAdminAgent::Http::Exceptions::HttpException)
+          return error.message
+        end
+
+        if (customizer = ForestAdminAgent::Facades::Container.cache(:customize_error_message))
+          message = eval(customizer).call(error)
+          return message if message
+        end
+
+        'Unexpected error'
+      end
+    end
+  end
+end

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

@@ -80,7 +80,7 @@ module ForestAdminAgent
             data,
             filter,
             {
-              change_field: nil,
+              change_field: args.dig(:params, :data, :attributes, :changed_field),
               search_field: nil,
               search_values: {},
               includeHiddenFields: false

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

@@ -20,24 +20,26 @@ module ForestAdminAgent
             "forest_chart_get_#{slug}",
             'get',
             "/_charts/#{slug}",
-            proc { handle_smart_chart }
+            proc { |args| handle_smart_chart(args) }
           )
 
           add_route(
             "forest_chart_post_#{slug}",
             'post',
             "/_charts/#{slug}",
-            proc { handle_api_chart }
+            proc { |args| handle_api_chart(args) }
           )
 
           unless Facades::Container.cache(:is_production)
-            Facades::Container.logger.log('Info', "/forest/_charts/#{slug}")
+            Facades::Container.logger.log('Info', "Chart #{@chart_name} was mounted at /forest/_charts/#{slug}")
           end
 
           self
         end
 
-        def handle_api_chart
+        def handle_api_chart(args = {})
+          @caller = Utils::QueryStringParser.parse_caller(args)
+
           {
             content: Serializer::ForestChartSerializer.serialize(
               @datasource.render_chart(
@@ -48,7 +50,9 @@ module ForestAdminAgent
           }
         end
 
-        def handle_smart_chart
+        def handle_smart_chart(args = {})
+          @caller = Utils::QueryStringParser.parse_caller(args)
+
           {
             content: @datasource.render_chart(
               @caller,

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

@@ -23,7 +23,9 @@ module ForestAdminAgent
                                                            ]),
             page: ForestAdminAgent::Utils::QueryStringParser.parse_pagination(args),
             search: ForestAdminAgent::Utils::QueryStringParser.parse_search(@collection, args),
-            search_extended: ForestAdminAgent::Utils::QueryStringParser.parse_search_extended(args)
+            search_extended: ForestAdminAgent::Utils::QueryStringParser.parse_search_extended(args),
+            sort: ForestAdminAgent::Utils::QueryStringParser.parse_sort(@collection, args),
+            segment: ForestAdminAgent::Utils::QueryStringParser.parse_segment(@collection, args)
           )
 
           projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@collection, args)

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

@@ -38,7 +38,7 @@ module ForestAdminAgent
               return {
                 name: @child_collection.name,
                 content: {
-                  count: result[0][:value]
+                  count: result.empty? ? 0 : result[0]['value']
                 }
               }
             end

data/lib/forest_admin_agent/serializer/forest_serializer.rb

@@ -16,7 +16,7 @@ module ForestAdminAgent
       end
 
       def base_url
-        Facades::Container.cache(:prefix)
+        '/forest'
       end
 
       def type
@@ -177,11 +177,11 @@ module ForestAdminAgent
       end
 
       def relationship_self_link(attribute_name)
-        "/#{self_link}/relationships/#{format_name(attribute_name)}"
+        "#{self_link}/relationships/#{format_name(attribute_name)}"
       end
 
       def relationship_related_link(attribute_name)
-        "/#{self_link}/#{format_name(attribute_name)}"
+        "#{self_link}/#{format_name(attribute_name)}"
       end
     end
   end

data/lib/forest_admin_agent/services/logger_service.rb

@@ -16,12 +16,11 @@ module ForestAdminAgent
         @logger_level = logger_level
         @logger = logger
         @default_logger = MonoLogger.new($stdout)
-        # TODO: HANDLE FORMATTER
       end
 
       def log(level, message)
         if @logger
-          @logger.call(get_level(level), message)
+          eval(@logger).call(get_level(level), message)
         else
           @default_logger.add(get_level(level), message)
         end

data/lib/forest_admin_agent/services/permissions.rb

@@ -95,7 +95,7 @@ module ForestAdminAgent
           filter
         )
 
-        smart_action_approval.can_execute?
+        is_allowed = smart_action_approval.can_execute?
         ForestAdminAgent::Facades::Container.logger.log(
           'Debug',
           "User #{user_data[:roleId]} is #{is_allowed ? "" : "not"} allowed to perform #{action["name"]}"
@@ -213,7 +213,8 @@ module ForestAdminAgent
         end[:enable]
       end
 
-      def find_action_from_endpoint(collection_name, endpoint, http_method)
+      def find_action_from_endpoint(collection_name, path, http_method)
+        endpoint = path.partition('/forest/')[1..].join
         schema_file = JSON.parse(File.read(Facades::Container.config_from_cache[:schema_path]))
         actions = schema_file['collections']&.select { |collection| collection['name'] == collection_name }&.first&.dig('actions')
 

data/lib/forest_admin_agent/services/sse_cache_invalidation.rb

@@ -26,18 +26,30 @@ module ForestAdminAgent
 
               MESSAGE_CACHE_KEYS[event.type]&.each do |cache_key|
                 Permissions.invalidate_cache(cache_key)
-                # TODO: HANDLE LOGGER
-                # "info","invalidate cache {MESSAGE_CACHE_KEYS[event.type]} for event {event.type}"
+                ForestAdminAgent::Facades::Container.logger.log(
+                  'Info',
+                  "invalidate cache #{MESSAGE_CACHE_KEYS[event.type]} for event #{event.type}"
+                )
               end
-              # TODO: HANDLE LOGGER add else
-              # "info", "SSECacheInvalidation: unhandled message from server: {event.type}"
+
+              ForestAdminAgent::Facades::Container.logger.log(
+                'Info',
+                "SSECacheInvalidation: unhandled message from server: #{event.type}"
+              )
             end
           end
         rescue StandardError
+          ForestAdminAgent::Facades::Container.logger.log(
+            'Debug',
+            'SSE connection to forestadmin server'
+          )
+
+          ForestAdminAgent::Facades::Container.logger.log(
+            'Warning',
+            'SSE connection to forestadmin server closed unexpectedly, retrying.'
+          )
+
           raise ForestException, 'Failed to reach SSE data from ForestAdmin server.'
-          # TODO: HANDLE LOGGER
-          # "debug", "SSE connection to forestadmin server due to ..."
-          # "warning", "SSE connection to forestadmin server closed unexpectedly, retrying."
         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
-          # TODO: call FieldValidator::validateValue($value, $field, $castedValue);
+          ForestAdminDatasourceToolkit::Validations::FieldValidator.validate_value(value, field, casted_value)
 
           [pk_name, casted_value]
         end.to_h

data/lib/forest_admin_agent/utils/query_string_parser.rb

@@ -23,16 +23,16 @@ module ForestAdminAgent
         return if filters.nil?
 
         filters = JSON.parse(filters, symbolize_names: true) if filters.is_a? String
-        # TODO: add else for convert all keys to sym
 
         ConditionTreeParser.from_plain_object(collection, filters)
-        # TODO: ConditionTreeValidator::validate($conditionTree, $collection);
       end
 
       def self.parse_caller(args)
         unless args.dig(:headers, 'HTTP_AUTHORIZATION')
-          # TODO: replace by http exception
-          raise ForestException, 'You must be logged in to access at this resource.'
+          raise Http::Exceptions::HttpException.new(
+            401,
+            'You must be logged in to access at this resource.'
+          )
         end
 
         timezone = args[:params]['timezone']
@@ -125,6 +125,17 @@ module ForestAdminAgent
 
         sort
       end
+
+      def self.parse_segment(collection, args)
+        segment = args.dig(:params, :data, :attributes, :all_records_subset_query,
+                           :segment) || args.dig(:params, :segment)
+
+        return unless segment
+
+        raise ForestException, "Invalid segment: #{segment}" unless collection.schema[:segments].include?(segment)
+
+        segment
+      end
     end
   end
 end

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

@@ -29,19 +29,20 @@ module ForestAdminAgent
 
         def self.make_form_data_from_fields(datasource, fields)
           data = {}
-          fields.each_value do |field|
-            next if Schema::GeneratorAction::DEFAULT_FIELDS.map { |f| f[:field] }.include?(field.field)
 
-            if field.reference && field.value
-              collection_name = field.reference.split('.').first
+          fields.each do |field|
+            next if Schema::GeneratorAction::DEFAULT_FIELDS.map { |f| f[:field] }.include?(field['field'])
+
+            if field['reference'] && field['value']
+              collection_name = field['reference'].split('.').first
               collection = datasource.get_collection(collection_name)
-              data[field.field] = Utils::Id.unpack_id(collection, field.value)
-            elsif field.type == 'File'
-              data[field.field] = parse_data_uri(field.value)
-            elsif field.type.is_a?(Array) && field.type[0] == 'File'
-              data[field.field] = field.value.map { |v| parse_data_uri(v) }
+              data[field['field']] = Utils::Id.unpack_id(collection, field['value'])
+            elsif field['type'] == 'File'
+              data[field['field']] = parse_data_uri(field['value'])
+            elsif field['type'].is_a?(Array) && field['type'][0] == 'File'
+              data[field['field']] = field['value'].map { |v| parse_data_uri(v) }
             else
-              data[field.field] = field.value
+              data[field['field']] = field['value']
             end
           end
 
@@ -83,7 +84,7 @@ module ForestAdminAgent
 
           return field.value.select { |v| field.enum_values.include?(v) } if ActionFields.enum_list_field?(field)
 
-          return field.value.join('|') if ActionFields.collection_field?(field)
+          return field.value&.join('|') if ActionFields.collection_field?(field)
 
           # return make_data_uri(field.value) if ActionFields.file_field?(field)
           #

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

@@ -0,0 +1,127 @@
+module ForestAdminAgent
+  module Utils
+    module Schema
+      class FrontendValidationUtils
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        # Those operators depend on the current time so they won't work.
+        # The reason is that we need now() to be evaluated at query time, not at schema generation time.
+        EXCLUDED = [Operators::FUTURE, Operators::PAST, Operators::TODAY, Operators::YESTERDAY,
+                    Operators::PREVIOUS_MONTH, Operators::PREVIOUS_QUARTER, Operators::PREVIOUS_WEEK,
+                    Operators::PREVIOUS_X_DAYS, Operators::PREVIOUS_YEAR, Operators::AFTER_X_HOURS_AGO,
+                    Operators::BEFORE_X_HOURS_AGO, Operators::PREVIOUS_X_DAYS_TO_DATE,
+                    Operators::PREVIOUS_MONTH_TO_DATE, Operators::PREVIOUS_QUARTER_TO_DATE,
+                    Operators::PREVIOUS_WEEK_TO_DATE, Operators::PREVIOUS_YEAR_TO_DATE].freeze
+
+        SUPPORTED = {
+          Operators::PRESENT => proc { { type: 'is present', message: 'Field is required' } },
+          Operators::AFTER => proc do |rule|
+            { type: 'is after', value: rule[:value], message: "Value must be after #{rule[:value]}" }
+          end,
+          Operators::BEFORE => proc do |rule|
+            { type: 'is before', value: rule[:value], message: "Value must be before #{rule[:value]}" }
+          end,
+          Operators::CONTAINS => proc do |rule|
+            { type: 'is contains', value: rule[:value], message: "Value must contain #{rule[:value]}" }
+          end,
+          Operators::GREATER_THAN => proc do |rule|
+            { type: 'is greater than', value: rule[:value], message: "Value must be greater than #{rule[:value]}" }
+          end,
+          Operators::LESS_THAN => proc do |rule|
+            { type: 'is less than', value: rule[:value], message: "Value must be lower than #{rule[:value]}" }
+          end,
+          Operators::LONGER_THAN => proc do |rule|
+            { type: 'is longer than', value: rule[:value],
+              message: "Value must be longer than #{rule[:value]} characters" }
+          end,
+          Operators::SHORTER_THAN => proc do |rule|
+            {
+              type: 'is shorter than',
+              value: rule[:value],
+              message: "Value must be shorter than #{rule[:value]} characters"
+            }
+          end,
+          Operators::MATCH => proc do |rule|
+            {
+              type: 'is like', # `is like` actually expects a regular expression, not a 'like pattern'
+              value: rule[:value].to_s,
+              message: "Value must match #{rule[:value]}"
+            }
+          end
+        }.freeze
+
+        def self.convert_validation_list(column)
+          return [] if column.validations.empty?
+
+          rules = column.validations.dup.map { |rule| simplify_rule(column.column_type, rule) }
+          remove_duplicates_in_place(rules).map { |rule| SUPPORTED[rule[:operator]].call(rule) }
+        end
+
+        def self.simplify_rule(column_type, rule)
+          return [] if EXCLUDED.include?(rule[:operator])
+
+          return rule if SUPPORTED.key?(rule[:operator])
+
+          begin
+            # Add the 'Equal|NotEqual' operators to unlock the `In|NotIn -> Match` replacement rules.
+            # This is a bit hacky, but it allows to reuse the existing logic.
+            operators = SUPPORTED.keys
+            operators << Operators::EQUAL
+            operators << Operators::NOT_EQUAL
+
+            # Rewrite the rule to use only operators that the frontend supports.
+            leaf = Nodes::ConditionTreeLeaf.new('field', rule[:operator], rule[:value])
+            timezone = 'Europe/Paris' # we're sending the schema => use random tz
+            tree = ConditionTreeEquivalent.get_equivalent_tree(leaf, operators, column_type, timezone)
+
+            if tree.is_a? Nodes::ConditionTreeLeaf
+              [tree]
+            else
+              tree.conditions
+            end
+          rescue StandardError
+            # Just ignore errors, they mean that the operator is not supported by the frontend
+            # and that we don't have an automatic conversion for it.
+            #
+            # In that case we fallback to just validating the data entry in the agent (which is better
+            # than nothing but will not be as user friendly as the frontend validation).
+          end
+
+          # Drop the rule if we don't know how to convert it (we could log a warning here).
+          []
+        end
+
+        # The frontend crashes when it receives multiple rules of the same type.
+        # This method merges the rules which can be merged and drops the others.
+        def self.remove_duplicates_in_place(rules)
+          used = {}
+          rules.each_with_index do |rule, key|
+            if used.key?(rule[:operator])
+              rule = rules[rule[:operator]]
+              new_rule = rule
+              rules.delete(key)
+              rules[used[rule[:operator]]] = merge_into(rule, new_rule)
+            else
+              used[rule[:operator]] = key
+            end
+          end
+
+          rules
+        end
+
+        def merge_into(rule, new_rule)
+          if [Operators::GREATER_THAN, Operators::AFTER, Operators::LONGER_THAN].include? rule[:operator]
+            rule[:value] = [rule[:value], new_rule[:value]].max
+          elsif [Operators::LESS_THAN, Operators::BEFORE, Operators::SHORTER_THAN].include? rule[:operator]
+            rule[:value] = [rule[:value], new_rule[:value]].min
+          elsif rule[:operator] == Operators::MATCH
+            # TODO
+          end
+          # else Ignore the rules that we can't deduplicate (we could log a warning here).
+
+          rule
+        end
+      end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ module ForestAdminAgent
 
           if ActionFields.collection_field?(field)
             collection = datasource.get_collection(field.collection_name)
-            pk = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection)
+            pk = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection)[0]
             pk_schema = collection.schema[:fields][pk]
 
             output[:type] = pk_schema.column_type
@@ -82,6 +82,7 @@ module ForestAdminAgent
             return DEFAULT_FIELDS unless action.static_form?
 
             fields = collection.get_form(nil, name)
+
             if fields
               return fields.map do |field|
                 new_field = build_field_schema(collection.datasource, field)

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

@@ -16,7 +16,7 @@ module ForestAdminAgent
             name: collection.name,
             onlyForRelationships: false,
             paginationType: 'page',
-            segments: {}
+            segments: build_segments(collection)
           }
         end
 
@@ -37,6 +37,14 @@ module ForestAdminAgent
             {}
           end
         end
+
+        def self.build_segments(collection)
+          if collection.schema[:segments]
+            collection.schema[:segments].keys.sort.map { |name| { id: "#{collection.name}.#{name}", name: name } }
+          else
+            []
+          end
+        end
       end
     end
   end

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

@@ -35,8 +35,7 @@ module ForestAdminAgent
               field: name,
               integration: nil,
               inverseOf: nil,
-              # isFilterable: FrontendFilterable.filterable?(column.column_type, column.filter_operators),
-              isFilterable: true, # TODO: remove when implementing operators decorators
+              isFilterable: FrontendFilterable.filterable?(column.column_type, column.filter_operators),
               isPrimaryKey: column.is_primary_key,
 
               # When a column is a foreign key, it is readonly.
@@ -48,7 +47,7 @@ module ForestAdminAgent
               isVirtual: false,
               reference: nil,
               type: convert_column_type(column.column_type),
-              validations: [] # TODO: FrontendValidationUtils.convertValidationList(column),
+              validations: FrontendValidationUtils.convert_validation_list(column)
             }
           end
 
@@ -67,9 +66,10 @@ module ForestAdminAgent
             }
           end
 
-          def foreign_collection_filterable?
-            # TODO: implement FrontendFilterable before
-            true
+          def foreign_collection_filterable?(foreign_collection)
+            foreign_collection.schema[:fields].values.any? do |field|
+              field.type == 'Column' && FrontendFilterable.filterable?(field.column_type, field.filter_operators)
+            end
           end
 
           def build_many_to_many_schema(relation, collection, foreign_collection, base_schema)
@@ -122,7 +122,7 @@ module ForestAdminAgent
               {
                 type: key_field.column_type,
                 defaultValue: nil,
-                isFilterable: foreign_collection_filterable?,
+                isFilterable: foreign_collection_filterable?(foreign_collection),
                 isPrimaryKey: false,
                 isRequired: false,
                 isReadOnly: key_field.is_read_only,
@@ -140,12 +140,12 @@ module ForestAdminAgent
               {
                 type: key_field.column_type,
                 defaultValue: key_field.default_value,
-                isFilterable: foreign_collection_filterable?,
+                isFilterable: foreign_collection_filterable?(foreign_collection),
                 isPrimaryKey: false,
-                isRequired: false, # TODO: check with validations
+                isRequired: key_field.validations.any? { |v| v[:operator] == 'Present' },
                 isReadOnly: key_field.is_read_only,
                 isSortable: key_field.is_sortable,
-                validations: [], # TODO: FrontendValidation::convertValidationList(foreignTargetColumn)
+                validations: FrontendValidationUtils.convert_validation_list(key_field),
                 reference: "#{foreign_collection.name}.#{relation.foreign_key_target}"
               }
             )
@@ -161,7 +161,7 @@ module ForestAdminAgent
               integration: nil,
               isReadOnly: nil,
               isVirtual: false,
-              inverseOf: nil, # TODO: CollectionUtils::getInverseRelation(collection, name)
+              inverseOf: ForestAdminDatasourceToolkit::Utils::Collection.get_inverse_relation(collection, name),
               relationship: RELATION_MAP[relation.type]
             }
 

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

@@ -7,7 +7,7 @@ module ForestAdminAgent
       class SchemaEmitter
         LIANA_NAME = "forest-rails"
 
-        LIANA_VERSION = "1.0.0-beta.48"
+        LIANA_VERSION = "1.0.0-beta.49"
 
         def self.get_serialized_schema(datasource)
           schema_path = Facades::Container.cache(:schema_path)

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.0.0-beta.48"
+  VERSION = "1.0.0-beta.49"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.48
+  version: 1.0.0.pre.beta.49
 platform: ruby
 authors:
 - Matthieu
@@ -238,6 +238,7 @@ files:
 - lib/forest_admin_agent/http/Exceptions/require_approval.rb
 - lib/forest_admin_agent/http/Exceptions/unprocessable_error.rb
 - lib/forest_admin_agent/http/Exceptions/validation_error.rb
+- lib/forest_admin_agent/http/error_handling.rb
 - lib/forest_admin_agent/http/forest_admin_api_requester.rb
 - lib/forest_admin_agent/http/router.rb
 - lib/forest_admin_agent/routes/abstract_authenticated_route.rb
@@ -280,6 +281,7 @@ files:
 - lib/forest_admin_agent/utils/schema/action_fields.rb
 - lib/forest_admin_agent/utils/schema/forest_value_converter.rb
 - lib/forest_admin_agent/utils/schema/frontend_filterable.rb
+- lib/forest_admin_agent/utils/schema/frontend_validation_utils.rb
 - lib/forest_admin_agent/utils/schema/generator_action.rb
 - lib/forest_admin_agent/utils/schema/generator_collection.rb
 - lib/forest_admin_agent/utils/schema/generator_field.rb