html2rss 0.28.0 → 0.30.0

data/lib/html2rss/request_service/botasaurus_strategy.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'faraday'
+require 'httpx'
 require 'json'
 require 'securerandom'
 
@@ -11,7 +11,7 @@ module Html2rss
     class BotasaurusStrategy < Strategy
       # Content-Type negotiation for the scrape API transport hop.
       TRANSPORT_ACCEPT = 'application/json'
-      # Disable compressed bodies so Faraday returns raw JSON without implicit decoding surprises.
+      # Disable compressed bodies so HTTPX returns raw JSON without implicit decoding surprises.
       TRANSPORT_ENCODING = 'identity'
       # Correlates each POST /scrape with botasaurus-scrape-api request logs.
       REQUEST_ID_HEADER = 'X-Request-Id'
@@ -28,10 +28,15 @@ module Html2rss
       def post_scrape_request
         request_id = SecureRandom.uuid
         Log.debug("#{self.class}: POST /scrape #{REQUEST_ID_HEADER}=#{request_id}")
-        transport_response = client.post('/scrape', JSON.generate(contract.request_payload), post_headers(request_id))
-        contract.parse_response(transport_response)
+        payload = JSON.generate(contract.request_payload)
+        response = client.post(scrape_endpoint, body: payload, headers: post_headers(request_id))
+        raise response.error if response.is_a?(HTTPX::ErrorResponse)
+
+        contract.parse_response(response)
       end
 
+      def scrape_endpoint = "#{scraper_base_url.to_s.chomp('/')}/scrape"
+
       def build_response(parsed_response)
         Response.new(
           body: parsed_response.html,
@@ -44,22 +49,14 @@ module Html2rss
       end
 
       def raise_from_error!(error)
-        raise_if_challenge_blocked!(error)
-        raise_if_timed_out!(error)
-        raise BotasaurusServiceError, error.failure_message
-      end
-
-      def raise_if_challenge_blocked!(error)
-        return unless error.challenge_block?
+        raise BlockedSurfaceDetected, "Blocked surface detected: #{error.challenge_message}" if error.challenge_block?
 
-        raise BlockedSurfaceDetected, "Blocked surface detected: #{error.challenge_message}"
-      end
-
-      def raise_if_timed_out!(error)
-        return unless error.timeout?
+        if error.timeout?
+          log_timeout!(reason: 'botasaurus_upstream')
+          raise RequestTimedOut.new(error.failure_message, timeout_phase: error.timeout_phase)
+        end
 
-        log_timeout!(reason: 'botasaurus_upstream')
-        raise RequestTimedOut.new(error.failure_message, timeout_phase: error.timeout_phase)
+        raise BotasaurusServiceError, error.failure_message
       end
 
       def response_url(final_url)
@@ -79,8 +76,18 @@ module Html2rss
       end
 
       def client
-        # No :gzip middleware on this client — compression is for remote target fetches only.
-        @client ||= Faraday.new(url: scraper_base_url.to_s, headers: client_headers, request: request_options)
+        timeout = attempt_timeout_seconds.to_f
+        @client ||= HTTPX.with(headers: client_headers, timeout: client_timeouts(timeout), resolver_class: :system)
+      end
+
+      def client_timeouts(timeout)
+        {
+          operation_timeout: timeout,
+          connect_timeout: [ctx.policy.connect_timeout_seconds, timeout].min,
+          read_timeout: [ctx.policy.read_timeout_seconds, timeout].min,
+          request_timeout: timeout,
+          total_request_timeout: timeout
+        }
       end
 
       def client_headers
@@ -92,14 +99,7 @@ module Html2rss
       end
 
       def post_headers(request_id)
-        {
-          'Content-Type' => 'application/json',
-          REQUEST_ID_HEADER => request_id
-        }
-      end
-
-      def request_options
-        { timeout: attempt_timeout_seconds.to_i }
+        { 'Content-Type' => 'application/json', REQUEST_ID_HEADER => request_id }
       end
 
       def attempt_timeout_seconds
@@ -123,6 +123,10 @@ module Html2rss
       def translate_connection_error(error)
         raise BotasaurusConnectionFailed, "Botasaurus connection failed: #{error.message}"
       end
+
+      def timeout_error?(error) = error.is_a?(HTTPX::TimeoutError) || super
+
+      def connection_error?(error) = error.is_a?(HTTPX::ConnectionError) || error.is_a?(HTTPX::TLSError) || super
     end
   end
 end

data/lib/html2rss/request_service/compressed_body.rb

@@ -45,9 +45,12 @@ module Html2rss
 
       def inflate(raw, encoding)
         case encoding
-        when 'gzip' then uncompress_gzip(raw)
-        when 'deflate' then inflate_deflate(raw)
+        when 'gzip'
+          return raw unless raw.start_with?(GZIP_MAGIC)
+
+          uncompress_gzip(raw)
         when 'br' then try_brotli(raw, require_html: false)
+        when 'deflate' then inflate_deflate(raw)
         end
       rescue Zlib::Error, Brotli::Error, ArgumentError
         nil
@@ -55,12 +58,6 @@ module Html2rss
       module_function :inflate
       private_class_method :inflate
 
-      def uncompress_gzip(raw)
-        Zlib::GzipReader.wrap(StringIO.new(raw), encoding: 'ASCII-8BIT', &:read)
-      end
-      module_function :uncompress_gzip
-      private_class_method :uncompress_gzip
-
       def inflate_deflate(raw)
         inflater = nil
         Zlib::Inflate.inflate(raw)
@@ -73,6 +70,14 @@ module Html2rss
       module_function :inflate_deflate
       private_class_method :inflate_deflate
 
+      def uncompress_gzip(raw)
+        Zlib::GzipReader.wrap(StringIO.new(raw), encoding: 'ASCII-8BIT', &:read)
+      rescue Zlib::Error
+        nil
+      end
+      module_function :uncompress_gzip
+      private_class_method :uncompress_gzip
+
       def try_brotli(raw, require_html: true)
         inflated = Brotli.inflate(raw)
         return inflated unless require_html

data/lib/html2rss/request_service/httpx_strategy.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'httpx'
+require 'httpx/plugins/follow_redirects'
+require 'httpx/plugins/callbacks'
+require 'httpx/plugins/ssrf_filter'
+require 'httpx/plugins/brotli'
+require 'httpx/plugins/fiber_concurrency'
+require 'httpx/plugins/retries'
+
+module Html2rss
+  class RequestService
+    ##
+    # Strategy to use HTTPX for HTTP requests.
+    # Provides native HTTP/2 with ALPN, built-in SSRF protection, streaming byte limits,
+    # and redirect handling without monkey-patching.
+    # rubocop:disable-next Metrics/ClassLength -- terminal redirect retry colocated with HTTPX transport
+    class HttpxStrategy < Strategy
+      class << self
+        # rubocop:disable ThreadSafety/ClassInstanceVariable
+        # @return [HTTPX::Session]
+        def base_session
+          @base_sessions ||= {}
+          @base_sessions[HTTPX::Session] ||= HTTPX
+                                             .plugin(:follow_redirects)
+                                             .plugin(:callbacks)
+                                             .plugin(:brotli)
+                                             .plugin(:fiber_concurrency)
+                                             .plugin(:retries)
+        end
+
+        # @return [HTTPX::Session]
+        def base_ssrf_session
+          @base_ssrf_sessions ||= {}
+          @base_ssrf_sessions[HTTPX::Session] ||= base_session.plugin(:ssrf_filter)
+        end
+        # rubocop:enable ThreadSafety/ClassInstanceVariable
+      end
+
+      ##
+      # @return [ResponseGuard]
+      attr_reader :response_guard
+
+      # Executes the request with runtime policy enforcement, returning the normalized response.
+      #
+      # @return [Response] normalized response
+      def perform_execute
+        deadline = request_deadline
+        @response_guard = ResponseGuard.new(policy: ctx.policy)
+        reset_redirect_tracking!
+        raw_response = request_with_terminal_redirect_retry(response_guard, deadline:)
+        build_response(raw_response)
+      end
+
+      private
+
+      def request_deadline
+        monotonic_now + ctx.budget.effective_timeout_seconds(fallback: ctx.policy.total_timeout_seconds)
+      end
+
+      def reset_redirect_tracking!
+        @last_redirect_to = nil
+        @terminal_redirect_retried = false
+        @request_url_override = nil
+        @current_url = request_url
+      end
+
+      def request_with_terminal_redirect_retry(response_guard, deadline:)
+        raw_response = execute_http_request(response_guard, deadline:)
+        return raw_response unless redirect_limit_reached?(raw_response)
+
+        unless terminal_redirect_retryable?(raw_response)
+          raise RedirectLimitReached, "Too many redirects (status #{raw_response.status})"
+        end
+
+        retry_from_terminal_redirect!(raw_response, response_guard, deadline:)
+      end
+
+      def redirect_limit_reached?(response)
+        return false unless response.is_a?(HTTPX::Response)
+        return false if response.status == 304
+        return false unless (300..399).cover?(response.status)
+
+        location = response.headers['location']
+        !location.nil? && !location.strip.empty?
+      end
+
+      def terminal_redirect_url(raw_response)
+        location = raw_response.headers['location']
+        if location && !location.empty?
+          base = raw_response.uri || request_url
+          return normalize_url(URI.join(base.to_s, location))
+        end
+
+        @last_redirect_to
+      end
+
+      def terminal_redirect_retryable?(raw_response)
+        return false if @terminal_redirect_retried
+
+        target = terminal_redirect_url(raw_response)
+        target && target.to_s != request_url.to_s
+      end
+
+      def retry_from_terminal_redirect!(raw_response, response_guard, deadline:)
+        terminal_url = terminal_redirect_url(raw_response)
+        @terminal_redirect_retried = true
+        Log.debug("#{self.class}: redirect limit reached; retrying once from #{terminal_url}")
+        begin_terminal_url_request!(terminal_url)
+        new_response = execute_http_request(response_guard, deadline:, consume_budget: false)
+        if redirect_limit_reached?(new_response)
+          raise RedirectLimitReached, "Too many redirects (status #{new_response.status})"
+        end
+
+        new_response
+      end
+
+      def begin_terminal_url_request!(terminal_url)
+        ctx.policy.validate_request!(url: terminal_url, origin_url: ctx.origin_url, relation: ctx.relation)
+        @request_url_override = terminal_url
+        @last_redirect_to = nil
+        @current_url = terminal_url
+      end
+
+      def request_url
+        @request_url_override || ctx.url
+      end
+
+      def execute_http_request(response_guard, deadline:, consume_budget: true)
+        preflight!(consume_budget:)
+        session = build_session(response_guard, deadline:)
+        response = session.get(request_url.to_s, headers: ctx.headers)
+        raise response.error if response.is_a?(HTTPX::ErrorResponse)
+
+        response
+      end
+
+      def build_session(_response_guard, deadline:)
+        session_client(deadline)
+      end
+
+      def session_client(deadline)
+        session = ctx.policy.allow_private_networks? ? self.class.base_session : self.class.base_ssrf_session
+        session.with(session_options(deadline))
+      end
+
+      def session_options(deadline)
+        remaining = remaining_timeout_seconds(deadline)
+        {
+          timeout: session_timeouts(remaining),
+          max_redirects: ctx.policy.max_redirects,
+          follow_insecure_redirects: false,
+          max_response_body_size: ctx.policy.max_response_bytes,
+          resolver_class: :system,
+          redirect_on: redirect_callback
+        }
+      end
+
+      def session_timeouts(remaining)
+        {
+          connect_timeout: [ctx.policy.connect_timeout_seconds, remaining].min,
+          read_timeout: [ctx.policy.read_timeout_seconds, remaining].min,
+          operation_timeout: remaining,
+          request_timeout: remaining,
+          total_request_timeout: remaining
+        }
+      end
+
+      def redirect_callback
+        lambda do |redirect_uri|
+          to_url = normalize_url(redirect_uri)
+          from_url = @current_url
+          @last_redirect_to = to_url
+          ctx.policy.validate_redirect!(from_url:, to_url:, origin_url: ctx.origin_url, relation: ctx.relation)
+          @current_url = to_url
+          true
+        end
+      end
+
+      def build_response(response)
+        headers = response.headers.to_h
+        Response.new(
+          body: CompressedBody.decode(response.body.to_s, headers:),
+          headers:,
+          url: response_url(response),
+          status: response.status
+        )
+      end
+
+      def response_url(response)
+        return ctx.url unless (uri = response.uri)
+
+        Html2rss::Url.from_absolute(uri.to_s)
+      end
+
+      def normalize_url(url)
+        Html2rss::Url.from_absolute(url.to_s)
+      end
+
+      def remaining_timeout_seconds(deadline)
+        remaining = deadline - monotonic_now
+        raise RequestTimedOut, 'Request timed out' if remaining <= 0
+
+        remaining
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def timeout_error?(error)
+        error.is_a?(HTTPX::TimeoutError) || super
+      end
+
+      def ssrf_error?(error)
+        error.is_a?(HTTPX::ServerSideRequestForgeryError) || super
+      end
+
+      def response_too_large_error?(error)
+        (error.is_a?(HTTPX::Error) && error.message.include?('maximum response body size exceeded')) || super
+      end
+
+      def connection_error?(error)
+        error.is_a?(HTTPX::ConnectionError) || error.is_a?(HTTPX::TLSError) || super
+      end
+    end
+  end
+end

data/lib/html2rss/request_service/policy.rb

@@ -84,11 +84,10 @@ module Html2rss
       # Returns the default request policy.
       #
       # @return [Policy] a default, frozen policy instance
-      # rubocop:disable Layout/ClassStructure
+      # rubocop:disable-next Layout/ClassStructure
       def self.default
         new
       end
-      # rubocop:enable Layout/ClassStructure
 
       ##
       # Validates whether a request target is permitted for the given context.

data/lib/html2rss/request_service/response.rb

@@ -31,7 +31,7 @@ module Html2rss
       # @param status [Integer, nil] the HTTP status code when available
       # @param transport_meta [Hash] allowlisted upstream telemetry (frozen when present)
       # @param captured_responses [Array<Hash>] JSON XHR/fetch bodies captured during browser scrapes
-      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists -- transport + capture fields stay co-located
+      # rubocop:disable-next Metrics/MethodLength, Metrics/ParameterLists -- transport + capture fields stay co-located
       def initialize(body:, url:, headers: {}, status: nil, transport_meta: EMPTY_TRANSPORT_META,
                      captured_responses: EMPTY_CAPTURED_RESPONSES)
         @body = body
@@ -50,7 +50,6 @@ module Html2rss
                                 captured_responses.freeze
                               end
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
 
       # @return [String] the raw body of the response
       attr_reader :body
@@ -160,12 +159,12 @@ module Html2rss
         return false if ct.empty? || ct.include?('html') || ct.include?('json')
 
         # Substring match against Content-Type (not Array#intersect? on a String).
-        FEED_CT_MARKERS.any? { |marker| ct.include?(marker) } # rubocop:disable Style/ArrayIntersect
+        FEED_CT_MARKERS.any? { |marker| ct.include?(marker) }
       end
 
       def feed_looking_body?
         snippet = body.to_s[0, 800].downcase
-        FEED_BODY_MARKERS.any? { |marker| snippet.include?(marker) } # rubocop:disable Style/ArrayIntersect
+        FEED_BODY_MARKERS.any? { |marker| snippet.include?(marker) }
       end
     end
   end

data/lib/html2rss/request_service/response_guard.rb

@@ -9,22 +9,6 @@ module Html2rss
       # @param policy [Policy] request policy that defines byte ceilings
       def initialize(policy:)
         @policy = policy
-        @streamed_bytes = 0
-      end
-
-      ##
-      # Validates response headers and streamed byte count.
-      #
-      # @param total_bytes [Integer] cumulative byte count received so far
-      # @param headers [Hash, nil] response headers if known
-      # @return [void]
-      # @raise [ResponseTooLarge] if the response exceeds configured limits
-      def inspect_chunk!(total_bytes:, headers: nil)
-        header_length = headers&.fetch('content-length', headers&.fetch('Content-Length', nil))
-        raise_if_too_large!(header_length.to_i, policy.max_response_bytes) if header_length
-
-        @streamed_bytes = total_bytes
-        raise_if_too_large!(@streamed_bytes, policy.max_response_bytes)
       end
 
       ##

data/lib/html2rss/request_service/strategy.rb

@@ -97,11 +97,16 @@ module Html2rss
       # @param error [StandardError]
       # @return [void]
       # @raise [StandardError]
+      # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength -- error translation dispatch
       def handle_error(error)
         if timeout_error?(error)
           log_timeout!(reason: 'transport')
           Log.debug("#{self.class}: transport timeout message=#{error.message}")
           raise RequestTimedOut, error.message
+        elsif ssrf_error?(error)
+          raise PrivateNetworkDenied, error.message
+        elsif response_too_large_error?(error)
+          raise ResponseTooLarge, "Response exceeded #{ctx.policy.max_response_bytes} bytes"
         elsif connection_error?(error)
           translate_connection_error(error)
         else
@@ -111,7 +116,7 @@ module Html2rss
 
       # @param reason [String] timeout classification (budget_exhausted / transport)
       # @return [void]
-      # rubocop:disable Metrics/AbcSize -- structured timeout fields stay in one log line
+      # rubocop:disable-next Metrics/AbcSize -- structured timeout fields stay in one log line
       def log_timeout!(reason:)
         remaining = ctx.budget.remaining_timeout_seconds
         remaining_label = remaining.nil? ? 'untracked' : format('%.3f', remaining)
@@ -124,7 +129,6 @@ module Html2rss
         ]
         Log.info("#{self.class}: request timeout #{detail.join(' ')}")
       end
-      # rubocop:enable Metrics/AbcSize
 
       # @param error [StandardError]
       # @return [void]
@@ -136,14 +140,25 @@ module Html2rss
       # @param error [StandardError]
       # @return [Boolean]
       def timeout_error?(error)
-        error.is_a?(Faraday::TimeoutError) ||
-          error.is_a?(Timeout::Error)
+        error.is_a?(Timeout::Error)
+      end
+
+      # @param _error [StandardError]
+      # @return [Boolean]
+      def ssrf_error?(_error)
+        false
+      end
+
+      # @param _error [StandardError]
+      # @return [Boolean]
+      def response_too_large_error?(_error)
+        false
       end
 
       # @param error [StandardError]
       # @return [Boolean]
       def connection_error?(error)
-        error.is_a?(Faraday::ConnectionFailed) || error.is_a?(Faraday::SSLError)
+        error.is_a?(SocketError) || error.is_a?(SystemCallError)
       end
     end
   end

data/lib/html2rss/request_service.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
-require 'singleton'
-require 'forwardable'
-
 module Html2rss
   ##
   # Requests website URLs to retrieve their HTML for further processing.
-  # Provides concrete transport strategies (e.g. Faraday, Botasaurus).
+  # Provides concrete transport strategies (e.g. HttpxStrategy, BotasaurusStrategy).
   #
   # Feed-level +:auto+ is not registered here — {FeedPipeline::StrategyPlan} resolves
   # it to a concrete strategy (or {FeedPipeline::AutoFallback} chain) before execute.
   class RequestService
-    include Singleton
-
     # Raised when an unknown request strategy is requested.
     class UnknownStrategy < Html2rss::Error; end
     # Raised when a URL cannot be parsed or validated.
@@ -29,6 +24,8 @@ module Html2rss
     class CrossOriginFollowUpDenied < Html2rss::Error; end
     # Raised when a response exceeds configured size limits.
     class ResponseTooLarge < Html2rss::Error; end
+    # Raised when HTTP redirect limits are exceeded.
+    class RedirectLimitReached < Html2rss::Error; end
     # Raised when blocked content surfaces are detected.
     class BlockedSurfaceDetected < Html2rss::Error; end
 
@@ -57,94 +54,60 @@ module Html2rss
     # Raised when Botasaurus responds but the scrape fails (upstream error, bad payload).
     class BotasaurusServiceError < Html2rss::Error; end
 
-    class << self
-      extend Forwardable
-
-      %i[default_strategy_name
-         default_strategy_name=
-         strategy_names
-         register_strategy
-         unregister_strategy
-         strategy_registered?
-         execute].each do |method|
-        def_delegator :instance, method
-      end
-    end
-
-    def initialize
-      @strategies = {
-        faraday: FaradayStrategy,
-        botasaurus: BotasaurusStrategy,
-        local_file: LocalFileStrategy
-      }
-      @default_strategy_name = :faraday
-    end
+    # Map of supported strategy names to their implementation classes.
+    # @return [Hash{Symbol => Class<Strategy>}]
+    STRATEGIES = {
+      default: HttpxStrategy,
+      httpx: HttpxStrategy,
+      faraday: HttpxStrategy,
+      botasaurus: BotasaurusStrategy,
+      local_file: LocalFileStrategy
+    }.freeze
 
-    # @return [Symbol] the default strategy name
-    attr_reader :default_strategy_name
+    # Canonical default strategy symbol.
+    # @return [Symbol]
+    DEFAULT_STRATEGY_NAME = :default
 
-    ##
-    # Sets the default strategy.
-    # @param strategy [Symbol] the name of the strategy
-    # @return [Symbol] the selected default strategy name
-    # @raise [UnknownStrategy] if the strategy is not registered
-    def default_strategy_name=(strategy)
-      raise UnknownStrategy unless strategy_registered?(strategy)
-
-      @default_strategy_name = strategy.to_sym
-    end
+    class << self
+      # @return [Symbol] the default strategy name
+      def default_strategy_name = DEFAULT_STRATEGY_NAME
 
-    # @return [Array<String>] the names of the registered strategies
-    def strategy_names = @strategies.keys.map(&:to_s)
+      # @return [Array<String>] the names of the registered strategies
+      def strategy_names = STRATEGIES.keys.map(&:to_s)
 
-    ##
-    # Registers a new strategy.
-    # @param name [Symbol] the name of the strategy
-    # @param strategy_class [Class] the class implementing the strategy
-    # @return [Class] the registered strategy class
-    # @raise [ArgumentError] if strategy_class is not a Class
-    def register_strategy(name, strategy_class)
-      unless strategy_class.is_a?(Class)
-        raise ArgumentError, "Expected a Class for strategy, got #{strategy_class.class}"
+      ##
+      # Checks if a strategy is registered.
+      # @param name [Symbol, String] the name of the strategy
+      # @return [Boolean] true if the strategy is registered, false otherwise.
+      def strategy_registered?(name)
+        STRATEGIES.key?(name.to_sym)
       end
 
-      @strategies[name.to_sym] = strategy_class
-    end
-
-    ##
-    # Checks if a strategy is registered.
-    # @param name [Symbol] the name of the strategy
-    # @return [Boolean] true if the strategy is registered, false otherwise.
-    def strategy_registered?(name)
-      @strategies.key?(name.to_sym)
-    end
-
-    ##
-    # Unregisters a strategy.
-    # @param name [Symbol] the name of the strategy
-    # @return [Boolean] true if the strategy was unregistered, false otherwise.
-    # @raise [ArgumentError] if attempting to unregister the default strategy.
-    def unregister_strategy(name) # rubocop:disable Naming/PredicateMethod
-      name_sym = name.to_sym
-      raise ArgumentError, 'Cannot unregister the default strategy.' if name_sym == @default_strategy_name
+      ##
+      # Executes the request using the specified strategy.
+      # @param ctx [Context] the context for the request.
+      # @param strategy [Symbol, String] the strategy to use (defaults to the default strategy).
+      # @return [Response] the response from the executed strategy.
+      # @raise [UnknownStrategy] if the strategy is not registered.
+      def execute(ctx, strategy: default_strategy_name)
+        strategy_sym = strategy.to_sym
+        strategy_class = STRATEGIES.fetch(strategy_sym) do
+          raise UnknownStrategy,
+                "The strategy '#{strategy}' is not known. Available strategies: #{strategy_names.join(', ')}"
+        end
+
+        warn_migration_strategy(strategy_sym) if strategy_sym == :faraday
+        strategy_class.new(ctx).execute
+      end
 
-      !!@strategies.delete(name_sym)
-    end
+      private
 
-    ##
-    # Executes the request using the specified strategy.
-    # @param ctx [Context] the context for the request.
-    # @param strategy [Symbol] the strategy to use (defaults to the default strategy).
-    # @return [Response] the response from the executed strategy.
-    # @raise [ArgumentError] if the context is nil.
-    # @raise [UnknownStrategy] if the strategy is not registered.
-    def execute(ctx, strategy: default_strategy_name)
-      strategy_class = @strategies.fetch(strategy.to_sym) do
-        raise UnknownStrategy,
-              "The strategy '#{strategy}' is not known. Available strategies: #{strategy_names.join(', ')}"
+      def warn_migration_strategy(strategy)
+        message = "RequestService: strategy ':#{strategy}' is deprecated for migration and will be removed " \
+                  "in a future release. Use ':default' instead."
+        warn(message, category: :deprecated)
+        Log.warn(message)
       end
-
-      strategy_class.new(ctx).execute
     end
   end
 end