Add response headers to NylasApiError object (#517)

Author: kraju3

lib/nylas/errors.rb

@@ -14,7 +14,7 @@ class JsonParseError < AbstractNylasSdkError; end
 
   # Error class representing a failed response from the Nylas API.
   class NylasApiError < AbstractNylasApiError
-    attr_accessor :type, :request_id, :provider_error, :status_code
+    attr_accessor :type, :request_id, :provider_error, :status_code, :headers
 
     # Initializes an error and assigns the given attributes to it.
     #
@@ -23,24 +23,26 @@ class NylasApiError < AbstractNylasApiError
     # @param status_code [Integer] Error status code.
     # @param provider_error [Hash, nil] The error from the provider.
     # @param request_id [Hash, nil] The ID of the request.
-    def initialize(type, message, status_code, provider_error = nil, request_id = nil)
+    def initialize(type, message, status_code, provider_error = nil, request_id = nil, headers = nil)
       super(message)
       self.type = type
       self.status_code = status_code
       self.provider_error = provider_error
       self.request_id = request_id
+      self.headers = headers
     end
 
     # Parses the error response.
     #
     # @param response [Hash] Response from the Nylas API.
     # @param status_code [Integer] Error status code.
-    def self.parse_error_response(response, status_code)
+    def self.parse_error_response(response, status_code, headers = nil)
       new(
         response["type"],
         response["message"],
         status_code,
-        response["provider_error"]
+        response["provider_error"],
+        headers
       )
     end
   end

lib/nylas/handler/http_client.rb

@@ -191,22 +191,26 @@ def handle_failed_response(http_code, response, path)
     def error_hash_to_exception(response, status_code, path)
       return if !response || !response.key?(:error)
 
+      # Safely get headers without risking KeyError
+      headers = response.key?(:headers) ? response[:headers] : nil
+
       if %W[#{api_uri}/v3/connect/token #{api_uri}/v3/connect/revoke].include?(path)
         NylasOAuthError.new(response[:error], response[:error_description], response[:error_uri],
                             response[:error_code], status_code)
       else
-        throw_error(response, status_code)
+        throw_error(response, status_code, headers)
       end
     end
 
-    def throw_error(response, status_code)
+    def throw_error(response, status_code, headers = nil)
       error_obj = response[:error]
 
       # If `error_obj` is just a string, turn it into a hash with default keys.
       if error_obj.is_a?(String)
         error_obj = {
           type: "NylasApiError",
-          message: error_obj
+          message: error_obj,
+          headers: headers
         }
       end
 
@@ -217,7 +221,8 @@ def throw_error(response, status_code)
         error_obj[:message],
         status_code,
         provider_error,
-        response[:request_id]
+        response[:request_id],
+        headers
       )
     end
 

spec/nylas/handler/http_client_spec.rb

@@ -240,6 +240,31 @@ class TestHttpClient
       expect(err_obj.provider_error).to eq("This is the provider error")
       expect(err_obj.type).to eq("api_error")
     end
+
+    it "raises the correct error with headers" do
+      response = {
+        request_id: "request-id",
+        error: {
+          type: "api_error",
+          message: "An unexpected error occurred",
+          provider_error: "This is the provider error"
+        }
+      }
+      headers = {
+        "x-request-id": "request-id-from-headers",
+        "x-ratelimit-limit": "100",
+        "x-ratelimit-remaining": "99"
+      }
+
+      err_obj = http_client.send(:throw_error, response, 400, headers)
+
+      expect(err_obj).to be_a(Nylas::NylasApiError)
+      expect(err_obj.message).to eq("An unexpected error occurred")
+      expect(err_obj.request_id).to eq("request-id")
+      expect(err_obj.provider_error).to eq("This is the provider error")
+      expect(err_obj.type).to eq("api_error")
+      expect(err_obj.headers).to eq(headers)
+    end
   end
 
   describe "#error_hash_to_exception" do
@@ -293,6 +318,31 @@ class TestHttpClient
       expect(err_obj.error_uri).to eq("https://tools.ietf.org/html/rfc6749#section-5.2")
       expect(err_obj.error_code).to eq(400)
     end
+
+    it "raises the correct error with headers" do
+      response = {
+        request_id: "request-id",
+        error: {
+          type: "api_error",
+          message: "An unexpected error occurred",
+          provider_error: "This is the provider error"
+        },
+        headers: {
+          "x-request-id": "request-id-from-headers",
+          "x-ratelimit-limit": "100",
+          "x-ratelimit-remaining": "99"
+        }
+      }
+
+      err_obj = http_client.send(:error_hash_to_exception, response, 400, "https://test.api.nylas.com/foo")
+
+      expect(err_obj).to be_a(Nylas::NylasApiError)
+      expect(err_obj.message).to eq("An unexpected error occurred")
+      expect(err_obj.request_id).to eq("request-id")
+      expect(err_obj.provider_error).to eq("This is the provider error")
+      expect(err_obj.type).to eq("api_error")
+      expect(err_obj.headers).to eq(response[:headers])
+    end
   end
 
   describe "#handle_failed_response" do