add rescue method to handle errors at StreamDecorator

Author: AbanoubGhadban

react_on_rails_pro/lib/react_on_rails_pro/stream_request.rb

@@ -10,6 +10,7 @@ def initialize(component)
       # @param position [Symbol] The position of the chunk in the stream (:first, :middle, or :last)
       # The position parameter is used by actions that add content to the beginning or end of the stream
       @actions = [] # List to store all actions
+      @rescue_blocks = []
     end
 
     # Add a prepend action
@@ -39,27 +40,45 @@ def append
       self # Return self to allow chaining
     end
 
+    def rescue(&block)
+      @rescue_blocks << block
+      self # Return self to allow chaining
+    end
+
     def handle_chunk(chunk, position)
       @actions.reduce(chunk) do |acc, action|
         action.call(acc, position)
       end
     end
 
-    def each_chunk
-      return enum_for(:each_chunk) unless block_given?
+    def each_chunk(&block)
+      return enum_for(:each_chunk) unless block
 
       first_chunk = true
       @component.each_chunk do |chunk|
         position = first_chunk ? :first : :middle
         modified_chunk = handle_chunk(chunk, position)
-        yield modified_chunk
+        block.call(modified_chunk)
         first_chunk = false
       end
 
       # The last chunk contains the append content after the transformation
       # All transformations are applied to the append content
       last_chunk = handle_chunk("", :last)
-      yield last_chunk unless last_chunk.empty?
+      block.call(last_chunk) unless last_chunk.empty?
+    rescue StandardError => err
+      current_error = err
+      rescue_block_index = 0
+      while current_error.present? && (rescue_block_index < @rescue_blocks.size)
+        begin
+          @rescue_blocks[rescue_block_index].call(current_error, &block)
+          current_error = nil
+        rescue StandardError => inner_error
+          current_error = inner_error
+        end
+        rescue_block_index += 1
+      end
+      raise current_error if current_error.present?
     end
   end
 
@@ -86,6 +105,9 @@ def each_chunk(&block)
         break
       rescue HTTPX::HTTPError => e
         send_bundle = handle_http_error(e, error_body, send_bundle)
+      rescue HTTPX::ReadTimeoutError => e
+        raise ReactOnRailsPro::Error, "Time out error while server side render streaming a component.\n" \
+                                      "Original error:\n#{e}\n#{e.backtrace}"
       end
     end
 
@@ -132,6 +154,7 @@ def loop_response_lines(response)
       line = "".b
 
       response.each do |chunk|
+        response.instance_variable_set(:@react_on_rails_received_first_chunk, true)
         line << chunk
 
         while (idx = line.index("\n"))

react_on_rails_pro/spec/react_on_rails_pro/stream_decorator_spec.rb

@@ -62,4 +62,93 @@
       expect(chunks.last).to end_with("-end")
     end
   end
+
+  describe "#rescue" do
+    it "catches the error happens inside the component" do
+      allow(mock_component).to receive(:each_chunk).and_raise(StandardError.new "Fake Error")
+      mocked_block = mock_block
+
+      stream_decorator.rescue(&mocked_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.not_to raise_error
+
+      expect(mocked_block).to have_received(:call) do |error|
+        expect(error).to be_a(StandardError)
+        expect(error.message).to eq("Fake Error")
+      end
+      expect(chunks).to eq([])
+    end
+
+    it "catches the error happens inside subsequent component calls" do
+      allow(mock_component).to receive(:each_chunk).and_yield("Chunk1").and_raise(ArgumentError.new "Fake Error")
+      mocked_block = mock_block
+
+      stream_decorator.rescue(&mocked_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.not_to raise_error
+
+      expect(mocked_block).to have_received(:call) do |error|
+        expect(chunks).to eq(["Chunk1"])
+        expect(error).to be_a(ArgumentError)
+        expect(error.message).to eq("Fake Error")
+      end
+      expect(chunks).to eq(["Chunk1"])
+    end
+
+    it "can yield values to the stream" do
+      allow(mock_component).to receive(:each_chunk).and_yield("Chunk1").and_raise(ArgumentError.new "Fake Error")
+      mocked_block = mock_block
+
+      stream_decorator.rescue(&mocked_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.not_to raise_error
+
+      expect(mocked_block).to have_received(:call) do |error, &inner_block|
+        expect(chunks).to eq(["Chunk1"])
+        expect(error).to be_a(ArgumentError)
+        expect(error.message).to eq("Fake Error")
+
+        inner_block.call "Chunk from rescue block"
+        inner_block.call "Chunk2 from rescue block"
+      end
+      expect(chunks).to eq(["Chunk1", "Chunk from rescue block", "Chunk2 from rescue block"])
+    end
+
+    it "can convert the error into another error" do
+      allow(mock_component).to receive(:each_chunk).and_raise(StandardError.new "Fake Error")
+      mocked_block = mock_block do |error|
+        expect(error).to be_a(StandardError)
+        expect(error.message).to eq("Fake Error")
+        raise ArgumentError.new "Another Error"
+      end
+
+      stream_decorator.rescue(&mocked_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.to raise_error(ArgumentError, "Another Error")
+      expect(chunks).to eq([])
+    end
+
+    it "chains multiple rescue blocks" do
+      allow(mock_component).to receive(:each_chunk).and_yield("Chunk1").and_raise(StandardError.new "Fake Error")
+      fist_rescue_block = mock_block do |error, &block|
+        expect(error).to be_a(StandardError)
+        expect(error.message).to eq("Fake Error")
+        block.call "Chunk from first rescue block"
+        raise ArgumentError.new "Another Error"
+      end
+
+      second_rescue_block = mock_block do |error, &block|
+        expect(error).to be_a(ArgumentError)
+        expect(error.message).to eq("Another Error")
+        block.call "Chunk from second rescue block"
+      end
+
+      stream_decorator.rescue(&fist_rescue_block.block)
+      stream_decorator.rescue(&second_rescue_block.block)
+      chunks = []
+      expect { stream_decorator.each_chunk { |chunk| chunks << chunk } }.not_to raise_error
+
+      expect(chunks).to eq(["Chunk1", "Chunk from first rescue block", "Chunk from second rescue block"])
+    end
+  end
 end

react_on_rails_pro/spec/react_on_rails_pro/support/mock_block_helper.rb

@@ -9,9 +9,11 @@ module MockBlockHelper
   # mocked_block = mock_block
   # testing_method_taking_block(&mocked_block.block)
   # expect(mocked_block).to have_received(:call).with(1, 2, 3)
-  def mock_block(return_value: nil)
+  def mock_block(&block)
     double("BlockMock").tap do |mock| # rubocop:disable RSpec/VerifiedDoubles
-      allow(mock).to receive(:call) { return_value }
+      allow(mock).to receive(:call) do |*args, &inner_block|
+        block.call(*args, &inner_block) if block
+      end
       def mock.block
         method(:call).to_proc
       end