Refactor errors

lib/seam/auth.rb

@@ -2,14 +2,9 @@
 
 require_relative "options"
 require_relative "token"
+require_relative "errors"
 
 module SeamAuth
-  class SeamInvalidTokenError < StandardError
-    def initialize(message)
-      super("Seam received an invalid token: #{message}")
-    end
-  end
-
   def self.get_auth_headers(api_key: nil, personal_access_token: nil, workspace_id: nil)
     if SeamOptions.seam_http_options_with_api_key?(api_key: api_key, personal_access_token: personal_access_token)
       return get_auth_headers_for_api_key(api_key)
@@ -29,23 +24,23 @@ def self.get_auth_headers(api_key: nil, personal_access_token: nil, workspace_id
 
   def self.get_auth_headers_for_api_key(api_key)
     if SeamAuth.client_session_token?(api_key)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "A Client Session Token cannot be used as an api_key"
       )
     end
 
-    raise SeamInvalidTokenError.new("A JWT cannot be used as an api_key") if SeamAuth.jwt?(api_key)
+    raise Http::SeamInvalidTokenError.new("A JWT cannot be used as an api_key") if SeamAuth.jwt?(api_key)
 
-    raise SeamInvalidTokenError.new("An Access Token cannot be used as an api_key") if SeamAuth.access_token?(api_key)
+    raise Http::SeamInvalidTokenError.new("An Access Token cannot be used as an api_key") if SeamAuth.access_token?(api_key)
 
     if SeamAuth.publishable_key?(api_key)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "A Publishable Key cannot be used as an api_key"
       )
     end
 
     unless SeamAuth.seam_token?(api_key)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "Unknown or invalid api_key format, expected token to start with #{SeamAuth::TOKEN_PREFIX}"
       )
     end
@@ -55,25 +50,25 @@ def self.get_auth_headers_for_api_key(api_key)
 
   def self.get_auth_headers_for_personal_access_token(personal_access_token, workspace_id)
     if SeamAuth.jwt?(personal_access_token)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "A JWT cannot be used as a personal_access_token"
       )
     end
 
     if SeamAuth.client_session_token?(personal_access_token)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "A Client Session Token cannot be used as a personal_access_token"
       )
     end
 
     if SeamAuth.publishable_key?(personal_access_token)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "A Publishable Key cannot be used as a personal_access_token"
       )
     end
 
     unless SeamAuth.access_token?(personal_access_token)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "Unknown or invalid personal_access_token format, expected token to start with #{SeamAuth::ACCESS_TOKEN_PREFIX}"
       )
     end
@@ -86,25 +81,25 @@ def self.get_auth_headers_for_personal_access_token(personal_access_token, works
 
   def self.get_auth_headers_for_multi_workspace_personal_access_token(personal_access_token)
     if SeamAuth.jwt?(personal_access_token)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "A JWT cannot be used as a personal_access_token"
       )
     end
 
     if SeamAuth.client_session_token?(personal_access_token)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "A Client Session Token cannot be used as a personal_access_token"
       )
     end
 
     if SeamAuth.publishable_key?(personal_access_token)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "A Publishable Key cannot be used as a personal_access_token"
       )
     end
 
     unless SeamAuth.access_token?(personal_access_token)
-      raise SeamInvalidTokenError.new(
+      raise Http::SeamInvalidTokenError.new(
         "Unknown or invalid personal_access_token format, expected token to start with #{SeamAuth::ACCESS_TOKEN_PREFIX}"
       )
     end

lib/seam/errors.rb

@@ -1,68 +1,73 @@
 # frozen_string_literal: true
 
 module Seam
-  module Errors
-    # HTTP
-    class SeamHttpApiError < StandardError
-      attr_reader :code, :status_code, :request_id, :data
+  class HttpApiError < StandardError
+    attr_reader :code, :status_code, :request_id, :data
 
-      def initialize(error, status_code, request_id)
-        super(error[:message])
-        @code = error[:type]
-        @status_code = status_code
-        @request_id = request_id
-        @data = error[:data]
-      end
+    def initialize(error, status_code, request_id)
+      super(error[:message])
+      @code = error[:type]
+      @status_code = status_code
+      @request_id = request_id
+      @data = error[:data]
     end
+  end
 
-    class SeamHttpUnauthorizedError < SeamHttpApiError
-      def initialize(request_id)
-        super({type: "unauthorized", message: "Unauthorized"}, 401, request_id)
-      end
+  class HttpUnauthorizedError < HttpApiError
+    def initialize(request_id)
+      super({type: "unauthorized", message: "Unauthorized"}, 401, request_id)
     end
+  end
 
-    class SeamHttpInvalidInputError < SeamHttpApiError
-      attr_reader :validation_errors
+  class InvalidInputError < HttpApiError
+    attr_reader :validation_errors
 
-      def initialize(error, status_code, request_id)
-        super(error, status_code, request_id)
-        @code = "invalid_input"
-        @validation_errors = error["validation_errors"] || {}
-      end
+    def initialize(error, status_code, request_id)
+      super(error, status_code, request_id)
+      @code = "invalid_input"
+      @validation_errors = error["validation_errors"] || {}
+    end
 
-      def get_validation_error_messages(param_name)
-        @validation_errors.dig(param_name, "_errors") || []
-      end
+    def get_validation_error_messages(param_name)
+      @validation_errors.dig(param_name, "_errors") || []
     end
+  end
 
-    # Action attempt
-    class SeamActionAttemptError < StandardError
-      attr_reader :action_attempt
+  # Action attempt
+  class ActionAttemptError < StandardError
+    attr_reader :action_attempt
 
-      def initialize(message, action_attempt)
-        super(message)
-        @action_attempt = action_attempt
-      end
+    def initialize(message, action_attempt)
+      super(message)
+      @action_attempt = action_attempt
+    end
 
-      def name
-        self.class.name
-      end
+    def name
+      self.class.name
     end
+  end
 
-    class SeamActionAttemptFailedError < SeamActionAttemptError
-      attr_reader :code
+  class ActionAttemptFailedError < ActionAttemptError
+    attr_reader :code
 
-      def initialize(action_attempt)
-        super(action_attempt.error.message, action_attempt)
-        @code = action_attempt.error.type
-      end
+    def initialize(action_attempt)
+      super(action_attempt.error.message, action_attempt)
+      @code = action_attempt.error.type
     end
+  end
+
+  class ActionAttemptTimeoutError < ActionAttemptError
+    def initialize(action_attempt, timeout)
+      message = "Timed out waiting for action attempt after #{timeout}s"
+      super(message, action_attempt)
+    end
+  end
+end
 
-    class SeamActionAttemptTimeoutError < SeamActionAttemptError
-      def initialize(action_attempt, timeout)
-        message = "Timed out waiting for action attempt after #{timeout}s"
-        super(message, action_attempt)
-      end
+module Http
+  class SeamInvalidTokenError < StandardError
+    def initialize(message)
+      super("Seam received an invalid token: #{message}")
     end
   end
 end

lib/seam/request.rb

@@ -34,7 +34,7 @@ def handle_error_response(response, _method, _uri)
       status_code = response.status.code
       request_id = response.headers["seam-request-id"]
 
-      raise Errors::SeamHttpUnauthorizedError.new(request_id) if status_code == 401
+      raise HttpUnauthorizedError.new(request_id) if status_code == 401
 
       error = response.parse["error"] || {}
       error_type = error["type"] || "unknown_error"
@@ -47,12 +47,12 @@ def handle_error_response(response, _method, _uri)
       if error_type == "invalid_input"
         error_details["validation_errors"] = error["validation_errors"]
 
-        raise Errors::SeamHttpInvalidInputError.new(
+        raise InvalidInputError.new(
           error_details, status_code, request_id
         )
       end
 
-      raise Errors::SeamHttpApiError.new(error_details, status_code, request_id)
+      raise HttpApiError.new(error_details, status_code, request_id)
     end
 
     def build_url(uri)

lib/seam/utils/action_attempt_utils.rb

@@ -24,12 +24,12 @@ def self.wait_until_finished(action_attempt, client, timeout: nil, polling_inter
           sleep(polling_interval)
           time_waiting += polling_interval
 
-          raise Errors::SeamActionAttemptTimeoutError.new(action_attempt, timeout) if time_waiting > timeout
+          raise ActionAttemptTimeoutError.new(action_attempt, timeout) if time_waiting > timeout
 
           action_attempt = update_action_attempt(action_attempt, client)
         end
 
-        raise Errors::SeamActionAttemptFailedError.new(action_attempt) if action_attempt.status == "error"
+        raise ActionAttemptFailedError.new(action_attempt) if action_attempt.status == "error"
 
         action_attempt
       end

spec/request_spec.rb

@@ -22,7 +22,7 @@
 
       it "parses the error" do
         expect { client.health }.to raise_error do |error|
-          expect(error).to be_a(Seam::Errors::SeamHttpApiError)
+          expect(error).to be_a(Seam::HttpApiError)
           expect(error.message).to eq(message)
           expect(error.code).to eq(type)
           expect(error.request_id).to eq(request_id)
@@ -48,7 +48,7 @@
 
       it "parses the error" do
         expect { client.health }.to raise_error do |error|
-          expect(error).to be_a(Seam::Errors::SeamHttpApiError)
+          expect(error).to be_a(Seam::HttpApiError)
           expect(error.message).to eq(message)
           expect(error.code).to eq(type)
           expect(error.request_id).to eq(request_id)

spec/seam_client/api_key_spec.rb

@@ -24,19 +24,19 @@
     it "checks api key format" do
       expect do
         Seam.from_api_key("some-invalid-key-format")
-      end.to raise_error(SeamAuth::SeamInvalidTokenError, /Unknown/)
+      end.to raise_error(Http::SeamInvalidTokenError, /Unknown/)
 
       expect do
         Seam.from_api_key("ey")
-      end.to raise_error(SeamAuth::SeamInvalidTokenError, /JWT/)
+      end.to raise_error(Http::SeamInvalidTokenError, /JWT/)
 
       expect do
         Seam.from_api_key("seam_cst_token")
-      end.to raise_error(SeamAuth::SeamInvalidTokenError, /Client Session Token/)
+      end.to raise_error(Http::SeamInvalidTokenError, /Client Session Token/)
 
       expect do
         Seam.from_api_key("seam_at")
-      end.to raise_error(SeamAuth::SeamInvalidTokenError, /Access Token/)
+      end.to raise_error(Http::SeamInvalidTokenError, /Access Token/)
     end
   end
 end

spec/seam_client/client_multi_workspace_spec.rb

@@ -39,10 +39,10 @@
 
   describe "token format validation" do
     it "raises SeamInvalidTokenError for invalid token formats" do
-      expect { described_class.from_personal_access_token("invalid_token") }.to raise_error(SeamAuth::SeamInvalidTokenError, /Unknown/)
-      expect { described_class.from_personal_access_token("seam_apikey_token") }.to raise_error(SeamAuth::SeamInvalidTokenError, /Unknown/)
-      expect { described_class.from_personal_access_token("seam_cst") }.to raise_error(SeamAuth::SeamInvalidTokenError, /Client Session Token/)
-      expect { described_class.from_personal_access_token("ey") }.to raise_error(SeamAuth::SeamInvalidTokenError, /JWT/)
+      expect { described_class.from_personal_access_token("invalid_token") }.to raise_error(Http::SeamInvalidTokenError, /Unknown/)
+      expect { described_class.from_personal_access_token("seam_apikey_token") }.to raise_error(Http::SeamInvalidTokenError, /Unknown/)
+      expect { described_class.from_personal_access_token("seam_cst") }.to raise_error(Http::SeamInvalidTokenError, /Client Session Token/)
+      expect { described_class.from_personal_access_token("ey") }.to raise_error(Http::SeamInvalidTokenError, /JWT/)
     end
   end
 end

spec/seam_client/http_error_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-RSpec.describe Seam::Errors::SeamHttpInvalidInputError do
+RSpec.describe Seam::InvalidInputError do
   let(:api_key) { "seam_apikey1_token" }
   let(:client) { Seam.new(api_key: api_key) }
 
@@ -19,7 +19,7 @@
       }
     end
 
-    it "raises SeamHttpInvalidInputError with correct validation messages" do
+    it "raises InvalidInputError with correct validation messages" do
       stub_seam_request(:post, "/devices/list",
         error_response,
         status: 400).with do |req|
@@ -28,7 +28,7 @@
 
       expect do
         client.devices.list(device_ids: 123)
-      end.to raise_error(Seam::Errors::SeamHttpInvalidInputError) do |error|
+      end.to raise_error(Seam::InvalidInputError) do |error|
         expect(error.code).to eq("invalid_input")
         expect(error.status_code).to eq(400)
         expect(error.get_validation_error_messages("device_ids")).to eq(["Expected array, received number"])
@@ -44,7 +44,7 @@
 
       begin
         client.devices.list(device_ids: 123)
-      rescue Seam::Errors::SeamHttpInvalidInputError => e
+      rescue Seam::InvalidInputError => e
         expect(e.get_validation_error_messages("non_existent_field")).to eq([])
       end
     end

spec/seam_client/personal_access_token_spec.rb

@@ -7,19 +7,19 @@
     it "raises error for invalid personal access token formats" do
       expect do
         Seam.from_personal_access_token("some-invalid-key-format", workspace_id)
-      end.to raise_error(SeamAuth::SeamInvalidTokenError, /Unknown/)
+      end.to raise_error(Http::SeamInvalidTokenError, /Unknown/)
 
       expect do
         Seam.from_personal_access_token("seam_apikey_token", workspace_id)
-      end.to raise_error(SeamAuth::SeamInvalidTokenError, /Unknown/)
+      end.to raise_error(Http::SeamInvalidTokenError, /Unknown/)
 
       expect do
         Seam.from_personal_access_token("seam_cst", workspace_id)
-      end.to raise_error(SeamAuth::SeamInvalidTokenError, /Client Session Token/)
+      end.to raise_error(Http::SeamInvalidTokenError, /Client Session Token/)
 
       expect do
         Seam.from_personal_access_token("ey", workspace_id)
-      end.to raise_error(SeamAuth::SeamInvalidTokenError, /JWT/)
+      end.to raise_error(Http::SeamInvalidTokenError, /JWT/)
     end
   end
 end