forest_admin_agent 1.12.11 → 1.12.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c483941707c8c57b9ae658ef3790d4b9292fe090d5fc15619970483b5c58f89
-  data.tar.gz: 4f8c9bc23a9a86f8d7850bad610f72d8dc31d4b485365a3e8d292e32f176a226
+  metadata.gz: dcedc2aca2e7965829e92f88f166f74264dd820084052ae74d225beb3a166aa8
+  data.tar.gz: 8931db8225893bcb912b3a445d88f6323d58bac33caf166051b5753df84c3676
 SHA512:
-  metadata.gz: 24a0f155ef3afc2350c3a27ee03e9ee6c02538d8685bcbe6cf90d77aeef2b192a139bc84b374679c5d4cdea0d9268a485492c4f6735eb965eda5fae9b4b768bb
-  data.tar.gz: b7ce5b4f9a40c6cbd79a48b60d8e1dda0bc9a21e907741837e4d2feca019eb115dfbea8f9b6f3d671bd839e819badb635a840766f969de8d1080d0cef12486b2
+  metadata.gz: 6faf436c5fbf5a3facf3313644f02483b990f09eaf10bd99aba7a96a999c6d45b9c9b8b426eaa19152627a1cf42f33d87b00a495417a5382876d231f6ee8b15b
+  data.tar.gz: e9a7c9e2e5763539a1dea190ed0c3cd46a2b5fff17b0aa447660695ba58faa5d37bedc23cbfac48a7be8383ceeeb8abaa9a95df54e14ce9aefc6399931946f95

data/lib/forest_admin_agent/auth/auth_manager.rb

@@ -15,7 +15,7 @@ module ForestAdminAgent
 
       def verify_code_and_generate_token(params)
         unless params['state']
-          raise ForestAdminAgent::Error,
+          raise ForestAdminAgent::Http::Exceptions::BadRequestError,
                 ForestAdminAgent::Utils::ErrorMessages::INVALID_STATE_MISSING
         end
 
@@ -40,14 +40,19 @@ module ForestAdminAgent
       def get_rendering_id_from_state(state)
         state = JSON.parse(state.tr("'", '"').gsub('=>', ':'))
         unless state.key? 'renderingId'
-          raise ForestAdminAgent::Error,
-                ForestAdminAgent::Utils::ErrorMessages::INVALID_STATE_RENDERING_ID
+          raise ForestAdminAgent::Http::Exceptions::BadRequestError.new(
+            ForestAdminAgent::Utils::ErrorMessages::INVALID_STATE_RENDERING_ID,
+            details: { state: state }
+          )
         end
 
         begin
           Integer(state['renderingId'])
         rescue ArgumentError
-          raise ForestAdminAgent::Error, ForestAdminAgent::Utils::ErrorMessages::INVALID_RENDERING_ID
+          raise ForestAdminAgent::Http::Exceptions::ValidationError.new(
+            ForestAdminAgent::Utils::ErrorMessages::INVALID_RENDERING_ID,
+            details: { renderingId: state['renderingId'] }
+          )
         end
 
         state['renderingId'].to_i

data/lib/forest_admin_agent/builder/agent_factory.rb

@@ -7,6 +7,7 @@ module ForestAdminAgent
     class AgentFactory
       include Singleton
       include ForestAdminAgent::Utils::Schema
+      include ForestAdminAgent::Http::Exceptions
       include ForestAdminDatasourceToolkit::Exceptions
 
       TTL_SCHEMA = 7200
@@ -46,6 +47,10 @@ module ForestAdminAgent
 
       def build
         @container.register(:datasource, @customizer.datasource(@logger))
+
+        # Reset route cache to ensure routes are computed with all customizations
+        ForestAdminAgent::Http::Router.reset_cached_routes!
+
         send_schema
       end
 
@@ -58,6 +63,11 @@ module ForestAdminAgent
         end
 
         @container.register(:datasource, @customizer.datasource(@logger), replace: true)
+
+        # Reset route cache before sending schema to ensure routes are recomputed with all customizations
+        ForestAdminAgent::Http::Router.reset_cached_routes!
+        @logger.log('Info', 'route cache cleared due to agent reload')
+
         send_schema
       end
 
@@ -73,7 +83,10 @@ module ForestAdminAgent
 
         if Facades::Container.cache(:is_production)
           unless schema_path && File.exist?(schema_path)
-            raise ForestException, "Can't load #{schema_path}. Providing a schema is mandatory in production."
+            raise InternalServerError.new(
+              'Schema file not found in production',
+              details: { schema_path: schema_path }
+            )
           end
 
           schema = JSON.parse(File.read(schema_path), symbolize_names: true)
@@ -143,8 +156,12 @@ module ForestAdminAgent
           response = client.post('/forest/apimaps/hashcheck', { schemaFileHash: hash }.to_json)
           body = JSON.parse(response.body)
           body['sendSchema']
-        rescue JSON::ParserError
-          raise ForestException, "Invalid JSON response from ForestAdmin server #{response.body}"
+        rescue JSON::ParserError => e
+          raise InternalServerError.new(
+            'Invalid JSON response from ForestAdmin server',
+            details: { body: response.body },
+            cause: e
+          )
         rescue Faraday::Error => e
           client.handle_response_error(e)
         end

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

@@ -0,0 +1,101 @@
+module ForestAdminAgent
+  module Http
+    module Exceptions
+      # Parent class for all business errors
+      # This is the base class that all specific error types inherit from
+      class BusinessError < StandardError
+        attr_reader :details, :cause
+
+        def initialize(message = nil, details: {}, cause: nil)
+          super(message)
+          @details = details || {}
+          @cause = cause
+        end
+
+        # Returns the name of the error class
+        def name
+          self.class.name.split('::').last
+        end
+      end
+
+      # ====================
+      # Specific error types
+      # ====================
+
+      class BadRequestError < BusinessError
+        def initialize(message = 'Bad request', details: {})
+          super
+        end
+      end
+
+      class ValidationError < BadRequestError
+        def initialize(message = 'Validation failed', details: {})
+          super
+        end
+      end
+
+      class UnauthorizedError < BusinessError
+        def initialize(message = 'Unauthorized', details: {})
+          super
+        end
+      end
+
+      class AuthenticationOpenIdClient < UnauthorizedError
+        def initialize(message = 'Authentication failed with OpenID Client', details: {})
+          super
+        end
+      end
+
+      class ForbiddenError < BusinessError
+        def initialize(message = 'Forbidden', details: {})
+          super
+        end
+      end
+
+      class NotFoundError < BusinessError
+        def initialize(message, details: {})
+          super
+        end
+      end
+
+      class ConflictError < BusinessError
+        def initialize(message = 'Conflict', details: {})
+          super
+        end
+      end
+
+      class UnprocessableError < BusinessError
+        def initialize(message = 'Unprocessable entity', details: {})
+          super
+        end
+      end
+
+      class TooManyRequestsError < BusinessError
+        attr_reader :retry_after
+
+        def initialize(message, retry_after, details: {})
+          super(message, details: details)
+          @retry_after = retry_after
+        end
+      end
+
+      class InternalServerError < BusinessError
+        def initialize(message = 'Internal server error', details: {}, cause: nil)
+          super
+        end
+      end
+
+      class BadGatewayError < BusinessError
+        def initialize(message = 'Bad gateway error', details: {}, cause: nil)
+          super
+        end
+      end
+
+      class ServiceUnavailableError < BusinessError
+        def initialize(message = 'Service unavailable error', details: {}, cause: nil)
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -1,14 +1,18 @@
+require_relative 'business_error'
+
 module ForestAdminAgent
   module Http
     module Exceptions
       class HttpException < StandardError
-        attr_reader :status, :message, :name
+        attr_reader :name, :status, :data, :custom_headers
 
-        def initialize(status, message, name = nil)
+        def initialize(status, name, message, data = {}, custom_headers = {})
           super(message)
+
           @status = status
-          @message = message
           @name = name
+          @data = data
+          @custom_headers = custom_headers
         end
       end
     end

data/lib/forest_admin_agent/http/error_translator.rb

@@ -0,0 +1,133 @@
+require_relative 'Exceptions/business_error'
+require_relative 'Exceptions/http_exception'
+
+module ForestAdminAgent
+  module Http
+    class ErrorTranslator
+      # Translate any exception to its appropriate HTTP error representation
+      # @param error [Exception] The error to translate
+      # @return [HttpException] The translated error with HTTP-specific properties
+      def self.translate(error)
+        return error if error.is_a?(Exceptions::HttpException)
+
+        name = error.class.name.split('::').last
+
+        status = get_error_status(error)
+
+        message = get_error_message(error)
+
+        data = get_error_data(error)
+
+        custom_headers = get_custom_headers(error)
+
+        Exceptions::HttpException.new(
+          status,
+          name,
+          message,
+          data,
+          custom_headers
+        )
+      end
+
+      # Get the HTTP status code for an error
+      # @param error [Exception] The error to get status for
+      # @return [Integer] The HTTP status code
+      def self.get_error_status(error)
+        if defined?(ForestAdminDatasourceToolkit::Exceptions::ValidationError) &&
+           of_type?(error, ForestAdminDatasourceToolkit::Exceptions::ValidationError)
+          return 400
+        end
+
+        error.status if error.respond_to?(:status) && error.status
+
+        case error
+        when Exceptions::ValidationError, Exceptions::BadRequestError
+          400
+        when Exceptions::UnauthorizedError
+          401
+        when Exceptions::ForbiddenError
+          403
+        when Exceptions::NotFoundError
+          404
+        when Exceptions::ConflictError
+          409
+        when Exceptions::UnprocessableError
+          422
+        when Exceptions::TooManyRequestsError
+          429
+        when Exceptions::InternalServerError
+          500
+        when Exceptions::BadGatewayError
+          502
+        when Exceptions::ServiceUnavailableError
+          503
+        when Exceptions::BusinessError
+          # default BusinessError → 422 (Unprocessable Entity)
+          422
+        else
+          # Unknown errors → 500 (Internal Server Error)
+          500
+        end
+      end
+
+      # Get the error message
+      # @param error [Exception] The error to get message from
+      # @return [String] The error message to send to the client
+      def self.get_error_message(error)
+        # Try custom error message customizer first
+        if defined?(ForestAdminAgent::Facades) &&
+           (customizer = ForestAdminAgent::Facades::Container.cache(:customize_error_message))
+          custom_message = eval(customizer).call(error)
+          return custom_message if custom_message
+        end
+
+        is_known_error = error.is_a?(Exceptions::HttpException) ||
+                         error.is_a?(Exceptions::BusinessError) ||
+                         (defined?(ForestAdminDatasourceToolkit::Exceptions::ForestException) &&
+                          error.is_a?(ForestAdminDatasourceToolkit::Exceptions::ForestException))
+
+        return error.message if is_known_error && error.message
+
+        'Unexpected error'
+      end
+
+      # Get error data/metadata
+      # @param error [Exception] The error to get data from
+      # @return [Hash, nil] The error metadata or nil
+      def self.get_error_data(error)
+        return error.details if error.is_a?(Exceptions::BusinessError) &&
+                                error.respond_to?(:details) &&
+                                !error.details.empty?
+
+        nil
+      end
+
+      # Get custom headers for specific error types
+      # @param error [Exception] The error to get headers for
+      # @return [Proc, nil] A proc that generates custom headers
+      def self.get_custom_headers(error)
+        case error
+        when Exceptions::NotFoundError
+          { 'x-error-type' => 'object-not-found' }
+        when Exceptions::TooManyRequestsError
+          { 'Retry-After' => error.retry_after.to_s }
+        end
+      end
+
+      # Check if an error is of a specific type (by class name)
+      # @param error [Exception] The error to check
+      # @param error_class [Class] The error class to check against
+      # @return [Boolean] True if the error is of the specified type
+      def self.of_type?(error, error_class)
+        # Direct instance check
+        return true if error.is_a?(error_class)
+
+        # Check by class name (handles cross-package version mismatches)
+        error.class.name.split('::').last == error_class.name.split('::').last
+      end
+
+      private_class_method :get_error_status, :get_error_message, :get_error_data,
+                           :get_custom_headers, :of_type?
+    end
+  end
+end

data/lib/forest_admin_agent/http/forest_admin_api_requester.rb

@@ -3,6 +3,7 @@ require 'faraday'
 module ForestAdminAgent
   module Http
     class ForestAdminApiRequester
+      include ForestAdminAgent::Http::Exceptions
       include ForestAdminDatasourceToolkit::Exceptions
 
       def initialize
@@ -28,29 +29,46 @@ module ForestAdminAgent
       end
 
       def handle_response_error(error)
+        # Re-raise if it's already a BusinessError
+        raise error if error.is_a?(ForestAdminAgent::Http::Exceptions::BusinessError)
         raise error if error.is_a?(ForestException)
 
         if error.response[:message]&.include?('certificate')
-          raise ForestException,
-                'ForestAdmin server TLS certificate cannot be verified. Please check that your system time is set properly.'
+          raise InternalServerError.new(
+            'ForestAdmin server TLS certificate cannot be verified. Please check that your system time is set properly.',
+            details: { error: error.message },
+            cause: error
+          )
         end
 
         if error.response[:status].zero? || error.response[:status] == 502
-          raise ForestException, 'Failed to reach ForestAdmin server. Are you online?'
+          raise BadGatewayError.new(
+            'Failed to reach ForestAdmin server. Are you online?',
+            details: { status: error.response[:status] },
+            cause: error
+          )
         end
 
         if error.response[:status] == 404
-          raise ForestException,
-                'ForestAdmin server failed to find the project related to the envSecret you configured. Can you check that you copied it properly in the Forest initialization?'
+          raise NotFoundError.new(
+            'ForestAdmin server failed to find the project related to the envSecret you configured. Can you check that you copied it properly in the Forest initialization?',
+            details: { status: error.response[:status] }
+          )
         end
 
         if error.response[:status] == 503
-          raise ForestException,
-                'Forest is in maintenance for a few minutes. We are upgrading your experience in the forest. We just need a few more minutes to get it right.'
+          raise ServiceUnavailableError.new(
+            'Forest is in maintenance for a few minutes. We are upgrading your experience in the forest. We just need a few more minutes to get it right.',
+            details: { status: error.response[:status] },
+            cause: error
+          )
         end
 
-        raise ForestException,
-              'An unexpected error occurred while contacting the ForestAdmin server. Please contact support@forestadmin.com for further investigations.'
+        raise InternalServerError.new(
+          'An unexpected error occurred while contacting the ForestAdmin server. Please contact support@forestadmin.com for further investigations.',
+          details: { status: error.response[:status], message: error.message },
+          cause: error
+        )
       end
     end
   end

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

@@ -7,6 +7,7 @@ module ForestAdminAgent
       class NativeQuery < AbstractAuthenticatedRoute
         include ForestAdminAgent::Builder
         include ForestAdminAgent::Utils
+        include ForestAdminAgent::Http::Exceptions
         include ForestAdminDatasourceToolkit::Exceptions
         include ForestAdminDatasourceToolkit::Components::Charts
         include ForestAdminAgent::Routes::QueryHandler
@@ -61,7 +62,7 @@ module ForestAdminAgent
         end
 
         def raise_error(result, key_names)
-          raise ForestException,
+          raise BadRequestError,
                 "The result columns must be named #{key_names} instead of '#{result.keys.join("', '")}'"
         end
 

data/lib/forest_admin_agent/routes/security/authentication.rb

@@ -42,8 +42,7 @@ module ForestAdminAgent
 
         def handle_authentication_callback(args = {})
           if args[:params].key?(:error)
-            raise AuthenticationOpenIdClient.new(args[:params][:error_description] || args[:params][:error],
-                                                 args[:params][:error])
+            raise AuthenticationOpenIdClient, args[:params][:error_description] || args[:params][:error]
           end
 
           if args.dig(:headers, 'action_dispatch.remote_ip')
@@ -80,14 +79,14 @@ module ForestAdminAgent
 
         def get_and_check_rendering_id(params)
           unless params['renderingId']
-            raise ForestAdminAgent::Error,
+            raise BadRequestError,
                   ForestAdminAgent::Utils::ErrorMessages::MISSING_RENDERING_ID
           end
 
           begin
             Integer(params['renderingId'])
           rescue ArgumentError
-            raise ForestAdminAgent::Error, ForestAdminAgent::Utils::ErrorMessages::INVALID_RENDERING_ID
+            raise ValidationError, ForestAdminAgent::Utils::ErrorMessages::INVALID_RENDERING_ID
           end
 
           params['renderingId'].to_i

data/lib/forest_admin_agent/services/ip_whitelist.rb

@@ -40,7 +40,7 @@ module ForestAdminAgent
         when RULE_MATCH_SUBNET
           ip_match_subnet?(ip, rule['range'])
         else
-          raise 'Invalid rule type'
+          raise ForestAdminAgent::Http::Exceptions::InternalServerError, 'Invalid rule type'
         end
       end
 
@@ -93,7 +93,8 @@ module ForestAdminAgent
                                                             status: response.status,
                                                             response: response.body
                                                           })
-          raise ForestAdminAgent::Error, ForestAdminAgent::Utils::ErrorMessages::UNEXPECTED
+          raise ForestAdminAgent::Http::Exceptions::InternalServerError,
+                ForestAdminAgent::Utils::ErrorMessages::UNEXPECTED
         end
 
         begin
@@ -104,7 +105,8 @@ module ForestAdminAgent
                                                             status: response.status,
                                                             response: response.body
                                                           })
-          raise ForestAdminAgent::Error, ForestAdminAgent::Utils::ErrorMessages::UNEXPECTED
+          raise ForestAdminAgent::Http::Exceptions::InternalServerError,
+                ForestAdminAgent::Utils::ErrorMessages::UNEXPECTED
         end
 
         ip_whitelist_data = body['data']['attributes']
@@ -117,7 +119,8 @@ module ForestAdminAgent
                                                           status: response&.status,
                                                           response: response&.body
                                                         })
-        raise ForestAdminAgent::Error, ForestAdminAgent::Utils::ErrorMessages::UNEXPECTED
+        raise ForestAdminAgent::Http::Exceptions::InternalServerError,
+              ForestAdminAgent::Utils::ErrorMessages::UNEXPECTED
       end
     end
   end

data/lib/forest_admin_agent/services/permissions.rb

@@ -263,7 +263,7 @@ module ForestAdminAgent
 
         action = actions.find { |a| a['endpoint'] == endpoint && a['httpMethod'].casecmp(http_method).zero? }
 
-        raise ForestException, "The collection #{collection_name} does not have this smart action" if action.nil?
+        raise BadRequestError, "The collection #{collection_name} does not have this smart action" if action.nil?
 
         action
       end
@@ -277,7 +277,10 @@ module ForestAdminAgent
             "Available keys: #{collection.is_a?(Hash) ? collection.keys.join(", ") : "N/A (not a hash)"}. " \
             'This indicates an API contract violation or data corruption.'
           )
-          raise ForestException, 'Invalid permission data structure received from Forest Admin API'
+          raise InternalServerError.new(
+            'Invalid permission data structure received from Forest Admin API',
+            details: { received_keys: collection.is_a?(Hash) ? collection.keys : nil }
+          )
         end
 
         collection_data = collection[:collection]
@@ -288,7 +291,10 @@ module ForestAdminAgent
             "Invalid permissions data: :collection is not a hash (got #{collection_data.class}). " \
             'This indicates an API contract violation or data corruption.'
           )
-          raise ForestException, 'Invalid permission data structure: :collection must be a hash'
+          raise InternalServerError.new(
+            'Invalid permission data structure: :collection must be a hash',
+            details: { collection_data_class: collection_data.class }
+          )
         end
 
         # Use dig to safely extract roles, allowing for missing permissions

data/lib/forest_admin_agent/services/smart_action_checker.rb

@@ -1,7 +1,26 @@
 module ForestAdminAgent
   module Services
+    include ForestAdminAgent::Http::Exceptions
+
+    class CustomActionTriggerForbiddenError < ForbiddenError
+      def initialize(message = 'Custom action trigger forbidden', details: {})
+        super
+      end
+    end
+
+    class InvalidActionConditionError < ConflictError
+      def initialize(message = 'Invalid action condition', details: {})
+        super
+      end
+    end
+
+    class CustomActionRequiresApprovalError < ForbiddenError
+      def initialize(message = 'Custom action requires approval', details: {})
+        super
+      end
+    end
+
     class SmartActionChecker
-      include ForestAdminAgent::Http::Exceptions
       include ForestAdminAgent::Utils
       include ForestAdminDatasourceToolkit::Utils
       include ForestAdminDatasourceToolkit::Components::Query
@@ -9,12 +28,6 @@ module ForestAdminAgent
 
       attr_reader :parameters, :collection, :smart_action, :caller, :role_id, :filter, :attributes
 
-      TRIGGER_FORBIDDEN_ERROR = 'CustomActionTriggerForbiddenError'.freeze
-
-      REQUIRE_APPROVAL_ERROR = 'CustomActionRequiresApprovalError'.freeze
-
-      INVALID_ACTION_CONDITION_ERROR = 'InvalidActionConditionError'.freeze
-
       def initialize(parameters, collection, smart_action, caller, role_id, filter)
         @parameters = parameters
         @collection = collection
@@ -43,7 +56,7 @@ module ForestAdminAgent
           return true
         end
 
-        raise ForbiddenError.new('You don\'t have the permission to trigger this action.', TRIGGER_FORBIDDEN_ERROR)
+        raise CustomActionTriggerForbiddenError, 'You don\'t have the permission to trigger this action.'
       end
 
       def can_trigger?
@@ -53,17 +66,16 @@ module ForestAdminAgent
           end
         elsif smart_action[:approvalRequired].include?(role_id) && smart_action[:triggerEnabled].include?(role_id)
           if condition_by_role_id(smart_action[:approvalRequiredConditions]).nil? || match_conditions(:approvalRequiredConditions)
-            raise RequireApproval.new(
+            raise CustomActionRequiresApprovalError.new(
               'This action requires to be approved.',
-              REQUIRE_APPROVAL_ERROR,
-              smart_action[:userApprovalEnabled]
+              details: { user_approval_enabled: smart_action[:userApprovalEnabled] }
             )
           elsif condition_by_role_id(smart_action[:triggerConditions]).nil? || match_conditions(:triggerConditions)
             return true
           end
         end
 
-        raise ForbiddenError.new('You don\'t have the permission to trigger this action.', TRIGGER_FORBIDDEN_ERROR)
+        raise CustomActionTriggerForbiddenError, 'You don\'t have the permission to trigger this action.'
       end
 
       def match_conditions(condition_name)
@@ -105,16 +117,10 @@ module ForestAdminAgent
         # Wrap other ForestExceptions (like invalid operators) in ConflictError
         raise if e.message.include?('has no primary keys')
 
-        raise ConflictError.new(
-          'The conditions to trigger this action cannot be verified. Please contact an administrator.',
-          INVALID_ACTION_CONDITION_ERROR
-        )
+        raise InvalidActionConditionError, 'The conditions to trigger this action cannot be verified. Please contact an administrator.'
       rescue ArgumentError, TypeError => e
         # Catch specific errors from condition parsing/validation
-        raise ConflictError.new(
-          "Invalid action condition: #{e.message}. Please contact an administrator.",
-          INVALID_ACTION_CONDITION_ERROR
-        )
+        raise InvalidActionConditionError, "Invalid action condition: #{e.message}. Please contact an administrator."
       rescue StandardError => e
         # Catch unexpected errors and log for debugging
         ForestAdminAgent::Facades::Container.logger.log(
@@ -122,10 +128,7 @@ module ForestAdminAgent
           "Unexpected error in match_conditions: #{e.class} - #{e.message}"
         )
 
-        raise ConflictError.new(
-          'The conditions to trigger this action cannot be verified. Please contact an administrator.',
-          INVALID_ACTION_CONDITION_ERROR
-        )
+        raise InvalidActionConditionError, 'The conditions to trigger this action cannot be verified. Please contact an administrator.'
       end
 
       def condition_by_role_id(condition)

data/lib/forest_admin_agent/services/sse_cache_invalidation.rb

@@ -3,6 +3,7 @@ require 'ld-eventsource'
 module ForestAdminAgent
   module Services
     class SSECacheInvalidation
+      include ForestAdminAgent::Http::Exceptions
       include ForestAdminDatasourceToolkit::Exceptions
 
       MESSAGE_CACHE_KEYS = {
@@ -38,7 +39,7 @@ module ForestAdminAgent
               )
             end
           end
-        rescue StandardError
+        rescue StandardError => e
           ForestAdminAgent::Facades::Container.logger.log(
             'Debug',
             'SSE connection to forestadmin server'
@@ -49,7 +50,11 @@ module ForestAdminAgent
             'SSE connection to forestadmin server closed unexpectedly, retrying.'
           )
 
-          raise ForestException, 'Failed to reach SSE data from ForestAdmin server.'
+          raise ServiceUnavailableError.new(
+            'Failed to reach SSE data from ForestAdmin server',
+            details: { error: e.message },
+            cause: e
+          )
         end
       end
     end

data/lib/forest_admin_agent/utils/caller_parser.rb

@@ -5,6 +5,7 @@ require 'active_support/time'
 module ForestAdminAgent
   module Utils
     class CallerParser
+      include ForestAdminAgent::Http::Exceptions
       include ForestAdminDatasourceToolkit::Exceptions
 
       def initialize(args)
@@ -29,16 +30,15 @@ module ForestAdminAgent
       def validate_headers
         return if @args.dig(:headers, 'HTTP_AUTHORIZATION')
 
-        raise Http::Exceptions::HttpException.new(
-          401,
-          'You must be logged in to access at this resource.'
-        )
+        raise Http::Exceptions::UnauthorizedError, 'You must be logged in to access at this resource.'
       end
 
       def extract_timezone
         timezone = @args[:params]['timezone']
-        raise ForestException, 'Missing timezone' unless timezone
-        raise ForestException, "Invalid timezone: #{timezone}" unless Time.find_zone(timezone)
+
+        raise BadRequestError, 'Missing timezone' unless timezone
+
+        raise BadRequestError, "Invalid timezone: #{timezone}" unless Time.find_zone(timezone)
 
         timezone
       end

data/lib/forest_admin_agent/utils/condition_tree_parser.rb

@@ -4,7 +4,7 @@ require 'active_support/time'
 module ForestAdminAgent
   module Utils
     class ConditionTreeParser
-      include ForestAdminDatasourceToolkit::Exceptions
+      include ForestAdminAgent::Http::Exceptions
       include ForestAdminDatasourceToolkit::Utils
       include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
       include ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes
@@ -26,7 +26,7 @@ module ForestAdminAgent
           return conditions.size == 1 ? conditions[0] : ConditionTreeBranch.new(aggregator, conditions)
         end
 
-        raise ForestException, 'Failed to instantiate condition tree'
+        raise BadRequestError, 'Failed to instantiate condition tree'
       end
 
       def self.parse_value(collection, leaf)

data/lib/forest_admin_agent/utils/query_string_parser.rb

@@ -1,6 +1,7 @@
 module ForestAdminAgent
   module Utils
     class QueryStringParser
+      include ForestAdminAgent::Http::Exceptions
       include ForestAdminDatasourceToolkit::Exceptions
       include ForestAdminDatasourceToolkit::Components
       include ForestAdminDatasourceToolkit::Components::Query
@@ -92,7 +93,7 @@ module ForestAdminAgent
         limit_valid = !items_per_pages.to_s.match(/\A[+]?\d+\z/).nil? && items_per_pages.to_i.positive?
 
         unless page_valid && limit_valid
-          raise ForestException, "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
+          raise BadRequestError, "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
         end
 
         offset = (page.to_i - 1) * items_per_pages.to_i
@@ -107,7 +108,7 @@ module ForestAdminAgent
       def self.parse_search(collection, args)
         search = args.dig(:params, :data, :attributes, :all_records_subset_query, :search) || args.dig(:params, :search)
 
-        raise ForestException, 'Collection is not searchable' if search && !collection.is_searchable?
+        raise BadRequestError, 'Collection is not searchable' if search && !collection.is_searchable?
 
         search
       end
@@ -148,7 +149,7 @@ module ForestAdminAgent
 
         return unless segment
 
-        raise ForestException, "Invalid segment: #{segment}" unless collection.schema[:segments].include?(segment)
+        raise BadRequestError, "Invalid segment: #{segment}" unless collection.schema[:segments].include?(segment)
 
         segment
       end

data/lib/forest_admin_agent/utils/query_validator.rb

@@ -8,7 +8,7 @@ module ForestAdminAgent
 
       def self.valid?(query)
         query = query.strip
-        raise ForestAdminDatasourceToolkit::Exceptions::ForestException, 'Query cannot be empty.' if query.empty?
+        raise Http::Exceptions::BadRequestError, 'Query cannot be empty.' if query.empty?
 
         sanitized_query = remove_content_inside_strings(query)
         check_select_only(sanitized_query)
@@ -21,30 +21,31 @@ module ForestAdminAgent
       end
 
       class << self
-        include ForestAdminDatasourceToolkit::Exceptions
-
         private
 
         def check_select_only(query)
           return if query.strip.upcase.start_with?('SELECT')
 
-          raise ForestException, 'Only SELECT queries are allowed.'
+          raise Http::Exceptions::BadRequestError, 'Only SELECT queries are allowed.'
         end
 
         def check_semicolon_placement(query)
           semicolon_count = query.scan(';').size
 
-          raise ForestException, 'Only one query is allowed.' if semicolon_count > 1
+          raise Http::Exceptions::BadRequestError, 'Only one query is allowed.' if semicolon_count > 1
           return if semicolon_count != 1 || query.strip[-1] == ';'
 
-          raise ForestException, 'Semicolon must only appear as the last character in the query.'
+          raise Http::Exceptions::BadRequestError, 'Semicolon must only appear as the last character in the query.'
         end
 
         def check_forbidden_keywords(query)
           FORBIDDEN_KEYWORDS.each do |keyword|
-            if /\b#{Regexp.escape(keyword)}\b/i.match?(query)
-              raise ForestException, "The query contains forbidden keyword: #{keyword}."
-            end
+            next unless /\b#{Regexp.escape(keyword)}\b/i.match?(query)
+
+            raise Http::Exceptions::BadRequestError.new(
+              "The query contains forbidden keyword: #{keyword}.",
+              details: { forbidden_keyword: keyword }
+            )
           end
         end
 
@@ -54,12 +55,17 @@ module ForestAdminAgent
 
           return if open_count == close_count
 
-          raise ForestException, 'The query contains unbalanced parentheses.'
+          raise Http::Exceptions::BadRequestError.new(
+            'The query contains unbalanced parentheses.',
+            details: { open_count: open_count, close_count: close_count }
+          )
         end
 
         def check_sql_injection_patterns(query)
           INJECTION_PATTERNS.each do |pattern|
-            raise ForestException, 'The query contains a potential SQL injection pattern.' if pattern.match?(query)
+            next unless pattern.match?(query)
+
+            raise Http::Exceptions::BadRequestError, 'The query contains a potential SQL injection pattern.'
           end
         end
 

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

@@ -2,7 +2,7 @@ module ForestAdminAgent
   module Utils
     module Schema
       class GeneratorActionFieldWidget
-        include ForestAdminDatasourceToolkit::Exceptions
+        include ForestAdminAgent::Http::Exceptions
 
         def self.build_widget_options(field)
           return if !ActionFields.widget?(field) || %w[Collection Enum EnumList].include?(field.type)
@@ -43,7 +43,10 @@ module ForestAdminAgent
 
           return build_address_autocomplete_widget_edit(field) if ActionFields.address_autocomplete_field?(field)
 
-          raise ForestException, "Unsupported widget type: #{field&.widget}"
+          raise InternalServerError.new(
+            "Unsupported widget type: #{field&.widget}",
+            details: { widget: field&.widget, field_type: field&.type }
+          )
         end
 
         class << self

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

data/lib/forest_admin_agent/version.rb

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

data/lib/forest_admin_agent.rb

@@ -1,4 +1,5 @@
 require_relative 'forest_admin_agent/version'
+require_relative 'forest_admin_agent/http/Exceptions/business_error'
 require 'zeitwerk'
 
 loader = Zeitwerk::Loader.for_gem

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.12.11
+  version: 1.12.13
 platform: ruby
 authors:
 - Matthieu
@@ -300,15 +300,9 @@ files:
 - lib/forest_admin_agent/builder/agent_factory.rb
 - lib/forest_admin_agent/facades/container.rb
 - lib/forest_admin_agent/facades/whitelist.rb
-- lib/forest_admin_agent/http/Exceptions/authentication_open_id_client.rb
-- lib/forest_admin_agent/http/Exceptions/conflict_error.rb
-- lib/forest_admin_agent/http/Exceptions/forbidden_error.rb
+- lib/forest_admin_agent/http/Exceptions/business_error.rb
 - lib/forest_admin_agent/http/Exceptions/http_exception.rb
-- lib/forest_admin_agent/http/Exceptions/not_found_error.rb
-- 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/error_translator.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

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

@@ -1,12 +0,0 @@
-module ForestAdminAgent
-  module Http
-    module Exceptions
-      class AuthenticationOpenIdClient < HttpException
-        def initialize(message = 'Authentication failed with OpenID Client',
-                       name = 'AuthenticationOpenIdClient')
-          super(401, message, name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module ForestAdminAgent
-  module Http
-    module Exceptions
-      class ConflictError < HttpException
-        attr_reader :name
-
-        def initialize(message, name = 'ConflictError')
-          super(429, message, name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module ForestAdminAgent
-  module Http
-    module Exceptions
-      class ForbiddenError < HttpException
-        attr_reader :name
-
-        def initialize(message, name = 'ForbiddenError')
-          super(403, message, name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module ForestAdminAgent
-  module Http
-    module Exceptions
-      class NotFoundError < HttpException
-        def initialize(message, name = 'NotFoundError')
-          super(404, message, name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module ForestAdminAgent
-  module Http
-    module Exceptions
-      class RequireApproval < HttpException
-        attr_reader :name, :data
-
-        def initialize(message, name = 'RequireApproval', data = [])
-          super(403, message, name)
-          @data = data
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module ForestAdminAgent
-  module Http
-    module Exceptions
-      class UnprocessableError < HttpException
-        attr_reader :name
-
-        def initialize(message = '', name = 'UnprocessableError')
-          super(422, message, name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module ForestAdminAgent
-  module Http
-    module Exceptions
-      class ValidationError < HttpException
-        attr_reader :name
-
-        def initialize(message, name = 'ValidationError')
-          super(400, message, name)
-        end
-      end
-    end
-  end
-end

data/lib/forest_admin_agent/http/error_handling.rb

@@ -1,28 +0,0 @@
-module ForestAdminAgent
-  module Http
-    module ErrorHandling
-      def get_error_message(error)
-        if error.class.respond_to?(:ancestors) && error.class.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
-
-        return error.message if error.is_a?(ForestAdminDatasourceToolkit::Exceptions::ValidationError)
-
-        'Unexpected error'
-      end
-
-      def get_error_status(error)
-        return error.status if error.respond_to?(:status) && error.status
-
-        return 400 if error.is_a?(ForestAdminDatasourceToolkit::Exceptions::ValidationError)
-
-        500
-      end
-    end
-  end
-end