Refactor errors

lib/seam.rb

@@ -1,31 +1,21 @@
 # frozen_string_literal: true
 
-require_relative "seam/version"
-require_relative "seam/lts_version"
-require_relative "seam/default_endpoint"
-require_relative "seam/request"
 require_relative "seam/logger"
 require_relative "seam/http"
-require_relative "seam/http_multi_workspace"
-require_relative "seam/base_client"
-require_relative "seam/base_resource"
-require_relative "seam/errors"
-require_relative "seam/seam_webhook"
-
-require_relative "seam/routes/resources/index"
-require_relative "seam/routes/clients/index"
+require_relative "seam/wait_for_action_attempt"
+require_relative "seam/webhook"
 
 module Seam
   def self.new(**args)
     Http.new(**args)
   end
 
   def self.from_api_key(api_key, endpoint: nil, wait_for_action_attempt: false, debug: false)
-    new(api_key: api_key, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt, debug: debug)
+    Http.from_api_key(api_key, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt, debug: debug)
   end
 
   def self.from_personal_access_token(personal_access_token, workspace_id, endpoint: nil, wait_for_action_attempt: false, debug: false)
-    new(personal_access_token: personal_access_token, workspace_id: workspace_id, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt, debug: debug)
+    Http.from_personal_access_token(personal_access_token, workspace_id, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt, debug: debug)
   end
 
   def self.lts_version

lib/seam/base_resource.rb

@@ -3,59 +3,61 @@
 require_relative "deep_hash_accessor"
 
 module Seam
-  class BaseResource
-    attr_accessor :data, :client
+  module Resources
+    class BaseResource
+      attr_accessor :data, :client
 
-    def initialize(data, client = nil)
-      @data = data
-      @client = client
+      def initialize(data, client = nil)
+        @data = data
+        @client = client
 
-      @data.each do |key, value|
-        value = Seam::DeepHashAccessor.new(value) if value.is_a?(Hash)
-        instance_variable_set(:"@#{key}", value)
+        @data.each do |key, value|
+          value = Seam::DeepHashAccessor.new(value) if value.is_a?(Hash)
+          instance_variable_set(:"@#{key}", value)
+        end
       end
-    end
 
-    def update_from_response(data)
-      @data = data
-      @data.each do |key, value|
-        instance_variable_set(:"@#{key}", value)
+      def update_from_response(data)
+        @data = data
+        @data.each do |key, value|
+          instance_variable_set(:"@#{key}", value)
+        end
       end
-    end
 
-    def self.load_from_response(data, client = nil)
-      if data.is_a?(Array)
-        data.map { |d| new(d, client) }
-      else
-        new(data, client)
+      def self.load_from_response(data, client = nil)
+        if data.is_a?(Array)
+          data.map { |d| new(d, client) }
+        else
+          new(data, client)
+        end
       end
-    end
 
-    def inspect
-      "<#{self.class.name}:#{"0x00%x" % (object_id << 1)}\n" + # rubocop:disable Style/StringConcatenation, Style/FormatString
-        instance_variables
-          .map { |k| k.to_s.sub("@", "") }
-          .filter { |k| k != "data" and k != "client" and respond_to? k }
-          .map { |k| "  #{k}=#{send(k).inspect}" }
-          .join("\n") + ">"
-    end
+      def inspect
+        "<#{self.class.name}:#{"0x00%x" % (object_id << 1)}\n" + # rubocop:disable Style/StringConcatenation, Style/FormatString
+          instance_variables
+            .map { |k| k.to_s.sub("@", "") }
+            .filter { |k| k != "data" and k != "client" and respond_to? k }
+            .map { |k| "  #{k}=#{send(k).inspect}" }
+            .join("\n") + ">"
+      end
 
-    def self.date_accessor(*attrs)
-      attrs.each do |attr|
-        define_method(attr) do
-          value = instance_variable_get(:"@#{attr}")
+      def self.date_accessor(*attrs)
+        attrs.each do |attr|
+          define_method(attr) do
+            value = instance_variable_get(:"@#{attr}")
 
-          raise "No value for #{attr} set" if value.nil?
+            raise "No value for #{attr} set" if value.nil?
 
-          parse_datetime(value)
+            parse_datetime(value)
+          end
         end
       end
-    end
 
-    protected
+      protected
 
-    def parse_datetime(value)
-      Time.parse(value)
+      def parse_datetime(value)
+        Time.parse(value)
+      end
     end
   end
 end

lib/seam/helpers/action_attempt.rb

@@ -26,12 +26,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 Seam::Http::WaitForActionAttempt::TimeoutError.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 Seam::Http::WaitForActionAttempt::FailedError.new(action_attempt) if action_attempt.status == "error"
 
         action_attempt
       end

lib/seam/http.rb

@@ -1,44 +1,51 @@
 # frozen_string_literal: true
 
-require_relative "parse_options"
-require_relative "routes/routes"
+require_relative "http_single_workspace"
 
 module Seam
-  class Http
-    include Seam::Routes
-
-    attr_accessor :defaults
-
-    def initialize(api_key: nil, personal_access_token: nil, workspace_id: nil, endpoint: nil,
-      wait_for_action_attempt: true, debug: false)
-      options = SeamOptions.parse_options(api_key: api_key, personal_access_token: personal_access_token, workspace_id: workspace_id, endpoint: endpoint)
-      @endpoint = options[:endpoint]
-      @auth_headers = options[:auth_headers]
-      @debug = debug
-      @wait_for_action_attempt = wait_for_action_attempt
-      @defaults = Seam::DeepHashAccessor.new({"wait_for_action_attempt" => wait_for_action_attempt})
+  module Http
+    def self.new(**args)
+      Http::SingleWorkspace.new(**args)
     end
 
-    def lts_version
-      Seam::LTS_VERSION
+    def self.from_api_key(api_key, endpoint: nil, wait_for_action_attempt: false, debug: false)
+      Http::SingleWorkspace.from_api_key(api_key, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt, debug: debug)
     end
 
-    def request_seam_object(method, path, klass, inner_object, config = {})
-      response = request_seam(method, path, config)
+    def self.from_personal_access_token(personal_access_token, workspace_id, endpoint: nil, wait_for_action_attempt: false, debug: false)
+      Http::SingleWorkspace.from_personal_access_token(personal_access_token, workspace_id, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt, debug: debug)
+    end
+
+    class HttpApiError < StandardError
+      attr_reader :code, :status_code, :request_id, :data
 
-      data = response[inner_object]
+      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
 
-      klass.load_from_response(data, self)
+    class HttpUnauthorizedError < HttpApiError
+      def initialize(request_id)
+        super({type: "unauthorized", message: "Unauthorized"}, 401, request_id)
+      end
     end
 
-    def request_seam(method, path, config = {})
-      Seam::Request.new(
-        auth_headers: @auth_headers,
-        endpoint: @endpoint,
-        debug: @debug
-      ).perform(
-        method, path, config
-      )
+    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 get_validation_error_messages(param_name)
+        @validation_errors.dig(param_name, "_errors") || []
+      end
     end
   end
 end

lib/seam/http_multi_workspace.rb

@@ -3,53 +3,56 @@
 require_relative "parse_options"
 require_relative "lts_version"
 require_relative "auth"
+require_relative "request"
 
 module Seam
-  class HttpMultiWorkspace
-    attr_reader :wait_for_action_attempt, :defaults
+  module Http
+    class MultiWorkspace
+      attr_reader :wait_for_action_attempt, :defaults
 
-    def initialize(personal_access_token:, endpoint: nil, wait_for_action_attempt: true)
-      @wait_for_action_attempt = wait_for_action_attempt
-      @defaults = {"wait_for_action_attempt" => wait_for_action_attempt}
-      @endpoint = SeamOptions.get_endpoint(endpoint)
-      @auth_headers = SeamAuth.get_auth_headers_for_multi_workspace_personal_access_token(personal_access_token)
-    end
+      def initialize(personal_access_token:, endpoint: nil, wait_for_action_attempt: true)
+        @wait_for_action_attempt = wait_for_action_attempt
+        @defaults = {"wait_for_action_attempt" => wait_for_action_attempt}
+        @endpoint = SeamOptions.get_endpoint(endpoint)
+        @auth_headers = SeamAuth.get_auth_headers_for_multi_workspace_personal_access_token(personal_access_token)
+      end
 
-    def self.lts_version
-      Seam::LTS_VERSION
-    end
+      def self.lts_version
+        Seam::LTS_VERSION
+      end
 
-    def lts_version
-      Seam::LTS_VERSION
-    end
+      def lts_version
+        Seam::LTS_VERSION
+      end
 
-    def workspaces
-      @workspaces ||= WorkspacesProxy.new(Seam::Clients::Workspaces.new(self))
-    end
+      def workspaces
+        @workspaces ||= WorkspacesProxy.new(Seam::Clients::Workspaces.new(self))
+      end
 
-    def self.from_personal_access_token(personal_access_token, endpoint: nil, wait_for_action_attempt: true)
-      new(
-        personal_access_token: personal_access_token,
-        endpoint: endpoint,
-        wait_for_action_attempt: wait_for_action_attempt
-      )
-    end
+      def self.from_personal_access_token(personal_access_token, endpoint: nil, wait_for_action_attempt: true)
+        new(
+          personal_access_token: personal_access_token,
+          endpoint: endpoint,
+          wait_for_action_attempt: wait_for_action_attempt
+        )
+      end
 
-    def request_seam_object(method, path, klass, inner_object, config = {})
-      response = request_seam(method, path, config)
+      def request_seam_object(method, path, klass, inner_object, config = {})
+        response = request_seam(method, path, config)
 
-      data = response[inner_object]
+        data = response[inner_object]
 
-      klass.load_from_response(data, self)
-    end
+        klass.load_from_response(data, self)
+      end
 
-    def request_seam(method, path, config = {})
-      Seam::Request.new(
-        auth_headers: @auth_headers,
-        endpoint: @endpoint
-      ).perform(
-        method, path, config
-      )
+      def request_seam(method, path, config = {})
+        Seam::Request.new(
+          auth_headers: @auth_headers,
+          endpoint: @endpoint
+        ).perform(
+          method, path, config
+        )
+      end
     end
   end
 end