my_api_client 0.13.0 → 0.16.1

data/lib/my_api_client/errors/api_limit_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For API request limit error
+  class ApiLimitError < Error; end
+end

data/lib/my_api_client/errors/client_error.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For 4xx client error
+  class ClientError < Error
+    # 400 Bad Request
+    class BadRequest < ClientError; end
+
+    # 401 Unauthorized
+    class Unauthorized < ClientError; end
+
+    # 402 Payment Required
+    class PaymentRequired < ClientError; end
+
+    # 403 Forbidden
+    class Forbidden < ClientError; end
+
+    # 404 Not Found
+    class NotFound < ClientError; end
+
+    # 405 Method Not Allowed
+    class MethodNotAllowed < ClientError; end
+
+    # 406 Not Acceptable
+    class NotAcceptable < ClientError; end
+
+    # 407 Proxy Authentication Required
+    class ProxyAuthenticationRequired < ClientError; end
+
+    # 408 Request Timeout
+    class RequestTimeout < ClientError; end
+
+    # 409 Conflict
+    class Conflict < ClientError; end
+
+    # 410 Gone
+    class Gone < ClientError; end
+
+    # 411 Length Required
+    class LengthRequired < ClientError; end
+
+    # 412 Precondition Failed
+    class PreconditionFailed < ClientError; end
+
+    # 413 Payload Too Large
+    class RequestEntityTooLarge < ClientError; end
+
+    # 414 URI Too Long
+    class RequestUriTooLong < ClientError; end
+
+    # 415 Unsupported Media Type
+    class UnsupportedMediaType < ClientError; end
+
+    # 416 Range Not Satisfiable
+    class RequestedRangeNotSatisfiable < ClientError; end
+
+    # 417 Expectation Failed
+    class ExpectationFailed < ClientError; end
+
+    # 418 I'm a teapot
+    class IamTeapot < ClientError; end
+
+    # 421 Misdirected Request
+    class MisdirectedRequest < ClientError; end
+
+    # 422 Unprocessable Entity
+    class UnprocessableEntity < ClientError; end
+
+    # 423 Locked
+    class Locked < ClientError; end
+
+    # 424 Failed Dependency
+    class FailedDependency < ClientError; end
+
+    # 425 Too Early
+    class TooEarly < ClientError; end
+
+    # 426 Upgrade Required
+    class UpgradeRequired < ClientError; end
+
+    # 428 Precondition Required
+    class PreconditionRequired < ClientError; end
+
+    # 429 Too Many Requests
+    class TooManyRequests < ClientError; end
+
+    # 431 Request Header Fields Too Large
+    class RequestHeaderFieldsTooLarge < ClientError; end
+
+    # 451 Unavailable for Legal Reasons
+    class UnavailableForLegalReasons < ClientError; end
+  end
+end

data/lib/my_api_client/errors/network_error.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  NETWORK_ERRORS = [
+    Faraday::TimeoutError,
+    Faraday::ConnectionFailed,
+    Faraday::SSLError,
+    OpenSSL::SSL::SSLError,
+    Net::OpenTimeout,
+    Net::ReadTimeout,
+    SocketError,
+  ].freeze
+
+  # Raises it when occurred to some network error
+  class NetworkError < Error
+    attr_reader :original_error
+
+    # Initialize the error class
+    #
+    # @param params [MyApiClient::Params::Params]
+    #   The request and response parameters
+    # @param original_error [StandardError]
+    #   Some network error
+    def initialize(params, original_error)
+      @original_error = original_error
+      super params, original_error.message
+    end
+
+    # Returns contents as string for to be readable for human
+    #
+    # @return [String] Contents as string
+    def inspect
+      { error: original_error, params: params }.inspect
+    end
+
+    # Generate metadata for bugsnag.
+    #
+    # @return [Hash] Metadata for bugsnag
+    def metadata
+      super.merge(original_error: original_error.inspect)
+    end
+  end
+end

data/lib/my_api_client/errors/server_error.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For 5xx server error
+  class ServerError < Error
+    # 500 Internal Server Error
+    class InternalServerError < ServerError; end
+
+    # 501 Not Implemented
+    class NotImplemented < ServerError; end
+
+    # 502 Bad Gateway
+    class BadGateway < ServerError; end
+
+    # 503 Service Unavailable
+    class ServiceUnavailable < ServerError; end
+
+    # 504 Gateway Timeout
+    class GatewayTimeout < ServerError; end
+
+    # 505 HTTP Version Not Supported
+    class HttpVersionNotSupported < ServerError; end
+
+    # 506 Variant Also Negotiates
+    class VariantAlsoNegotiates < ServerError; end
+
+    # 507 Insufficient Storage
+    class InsufficientStorage < ServerError; end
+
+    # 508 Loop Detected
+    class LoopDetected < ServerError; end
+
+    # 509 Bandwidth Limit Exceeded
+    class BandwidthLimitExceeded < ServerError; end
+
+    # 510 Not Extended
+    class NotExtended < ServerError; end
+
+    # 511 Network Authentication Required
+    class NetworkAuthenticationRequired < ServerError; end
+  end
+end

data/lib/my_api_client/params/request.rb

@@ -4,20 +4,18 @@ module MyApiClient
   module Params
     # Description of Params
     class Request
-      attr_reader :method, :pathname, :headers, :query, :body
+      attr_reader :method, :uri, :headers, :body
 
       # Description of #initialize
       #
       # @param method [Symbol] describe_method_here
-      # @param pathname [String] describe_pathname_here
+      # @param uri [URI] describe_uri_here
       # @param headers [Hash, nil] describe_headers_here
-      # @param query [Hash, nil] describe_query_here
       # @param body [Hash, nil] describe_body_here
-      def initialize(method, pathname, headers, query, body)
+      def initialize(method, uri, headers, body)
         @method = method
-        @pathname = pathname
+        @uri = uri
         @headers = headers
-        @query = query
         @body = body
       end
 
@@ -25,7 +23,7 @@ module MyApiClient
       #
       # @return [Array<Object>] Arguments for Sawyer::Agent#call
       def to_sawyer_args
-        [method, pathname, body, { headers: headers, query: query }]
+        [method, uri.to_s, body, { headers: headers }]
       end
 
       # Generate metadata for bugsnag.
@@ -34,9 +32,8 @@ module MyApiClient
       # @return [Hash] Metadata for bugsnag
       def metadata
         {
-          line: "#{method.upcase} #{pathname}",
+          line: "#{method.upcase} #{uri}",
           headers: headers,
-          query: query,
           body: body,
         }.compact
       end
@@ -46,7 +43,7 @@ module MyApiClient
       #
       # @return [String] Contents as string
       def inspect
-        { method: method, pathname: pathname, headers: headers, query: query, body: body }.inspect
+        { method: method, uri: uri.to_s, headers: headers, body: body }.inspect
       end
     end
   end

data/lib/my_api_client/request.rb

@@ -1,87 +1,65 @@
 # frozen_string_literal: true
 
 module MyApiClient
-  # Description of Request
+  # Provides HTTP request method.
   module Request
-    # Description of #_request
-    #
-    # @param http_method [Symbol] describe_http_method_here
-    # @param pathname [String] describe_pathname_here
-    # @param headers [Hash, nil] describe_headers_here
-    # @param query [Hash, nil] describe_query_here
-    # @param body [Hash, nil] describe_body_here
-    # @param logger [::Logger] describe_logger_here
-    # @return [Sawyer::Resource] description_of_returned_object
-    # rubocop:disable Metrics/ParameterLists
-    def _request(http_method, pathname, headers, query, body, logger)
-      processed_path = [common_path, pathname].join('/').gsub('//', '/')
-      request_params = Params::Request.new(http_method, processed_path, headers, query, body)
-      agent # Initializes for faraday
-      request_logger = Logger.new(logger, faraday, http_method, processed_path)
-      call(:_execute, request_params, request_logger)
-    end
-    # rubocop:enable Metrics/ParameterLists
+    include Basic
+    include Pagination
 
     private
 
-    # Description of #agent
-    #
-    # @return [Sawyer::Agent] description_of_returned_object
-    def agent
-      @agent ||= Sawyer::Agent.new(schema_and_hostname, faraday: faraday)
-    end
-
-    # Description of #faraday
+    # Executes HTTP request with relative URI.
     #
-    # @return [Faraday::Connection] description_of_returned_object
-    def faraday
-      @faraday ||=
-        Faraday.new(
-          nil,
-          request: {
-            timeout: (http_read_timeout if respond_to?(:http_read_timeout)),
-            open_timeout: (http_open_timeout if respond_to?(:http_open_timeout)),
-          }.compact
-        )
+    # @param http_method [Symbol]
+    #   HTTP method. e.g. `:get`, `:post`, `:put`, `:patch` and `:delete`.
+    # @param pathname [String]
+    #   Pathname of the request target URL.
+    #   It's joined with the defined by `endpoint`.
+    # @param headers [Hash, nil]
+    #   Request headers.
+    # @param query [Hash, nil]
+    #   Query string.
+    # @param body [Hash, nil]
+    #   Request body.
+    # @return [Sawyer::Response]
+    #   Response instance.
+    def _request_with_relative_uri(http_method, pathname, headers, query, body)
+      query_strings = query.present? ? '?' + query&.to_query : ''
+      uri = URI.join(File.join(endpoint, pathname), query_strings)
+      _request_with_absolute_uri(http_method, uri, headers, body)
     end
 
-    # Description of #_execute
+    # Executes HTTP request with absolute URI.
     #
-    # @param request_params [MyApiClient::Params::Request] describe_request_params_here
-    # @param request_logger [MyApiClient::Logger] describe_request_logger_here
-    # @return [Sawyer::Resource] description_of_returned_object
-    # @raise [MyApiClient::Error]
-    def _execute(request_params, request_logger)
-      request_logger.info('Start')
-      response = agent.call(*request_params.to_sawyer_args)
-      request_logger.info("Duration #{response.timing} sec")
-      params = Params::Params.new(request_params, response)
-      _verify(params, request_logger)
-    rescue *NETWORK_ERRORS => e
-      params ||= Params::Params.new(request_params, nil)
-      request_logger.error("Network Error (#{e.message})")
-      raise MyApiClient::NetworkError.new(params, e)
-    rescue MyApiClient::Error => e
-      request_logger.warn("Failure (#{response.status})")
-      raise e
-    else
-      request_logger.info("Success (#{response.status})")
-      response.data
+    # @param http_method [Symbol]
+    #   HTTP method. e.g. `:get`, `:post`, `:put`, `:patch` and `:delete`.
+    # @param uri [URI]
+    #   Request target URI including query strings.
+    # @param headers [Hash, nil]
+    #   Request headers.
+    # @param body [Hash, nil]
+    #   Request body.
+    # @return [Sawyer::Response]
+    #   Response instance.
+    def _request_with_absolute_uri(http_method, uri, headers, body)
+      Executor.call(
+        instance: self,
+        request_params: Params::Request.new(http_method, uri, headers, body),
+        request_logger: Logger.new(logger, http_method, uri),
+        faraday_options: faraday_options
+      )
     end
 
-    # Description of #_verify
+    # Generates options for the faraday instance.
     #
-    # @param params [MyApiClient::Params::Params] describe_params_here
-    # @param request_logger [MyApiClient::Logger] describe_request_logger_here
-    # @return [nil] description_of_returned_object
-    # @raise [MyApiClient::Error]
-    def _verify(params, request_logger)
-      case error_handler = error_handling(params.response)
-      when Proc
-        error_handler.call(params, request_logger)
-      when Symbol
-        send(error_handler, params, request_logger)
-      end
+    # @return [Hash] Generated options.
+    def faraday_options
+      {
+        request: {
+          timeout: (http_read_timeout if respond_to?(:http_read_timeout)),
+          open_timeout: (http_open_timeout if respond_to?(:http_open_timeout)),
+        }.compact,
+      }
     end
   end
 end

data/lib/my_api_client/request/basic.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  module Request
+    # Provides basic HTTP request method.
+    module Basic
+      HTTP_METHODS = %i[get post put patch delete].freeze
+
+      HTTP_METHODS.each do |http_method|
+        class_eval <<~METHOD, __FILE__, __LINE__ + 1
+          # Executes HTTP request with #{http_method.upcase} method
+          #
+          # @param pathname [String]
+          #   Pathname of the request target URL.
+          #   It's joined with the defined by `endpoint`.
+          # @param headers [Hash, nil]
+          #   Request headers.
+          # @param query [Hash, nil]
+          #   Query string.
+          # @param body [Hash, nil]
+          #   Request body. You should not specify it when use GET method.
+          # @return [Sawyer::Resource]
+          #   Response body instance.
+          def #{http_method}(pathname, headers: nil, query: nil, body: nil)
+            response = call(:_request_with_relative_uri, :#{http_method}, pathname, headers, query, body)
+            response.data
+          end
+        METHOD
+      end
+    end
+  end
+end

data/lib/my_api_client/request/executor.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  module Request
+    # Executes HTTP request with specified parameters.
+    class Executor < ServiceAbstract
+      # @param instance [MyApiClient::Base]
+      #   The my_api_client instance.
+      #   The instance method will be called on error handling.
+      # @param request_params [MyApiClient::Params::Request]
+      #   Request parameter instance.
+      # @param request_logger [MyApiClient::Logger]
+      #   Request logger instance.
+      # @param faraday_options [Hash]
+      #   Options for the faraday instance. Mainly used for timeout settings.
+      # @return [Sawyer::Response]
+      #   Response instance.
+      # @raise [MyApiClient::Error]
+      #   Raises on invalid response or network errors.
+      def initialize(instance:, request_params:, request_logger:, faraday_options:)
+        @instance = instance
+        @request_params = request_params
+        @request_logger = request_logger
+        faraday = Faraday.new(nil, faraday_options)
+        @agent = Sawyer::Agent.new('', faraday: faraday)
+      end
+
+      private
+
+      attr_reader :instance, :request_params, :request_logger, :agent
+
+      def call
+        request_logger.info('Start')
+        response = api_request
+        request_logger.info("Duration #{response.timing} sec")
+        verify(response)
+      rescue MyApiClient::Error => e
+        request_logger.warn("Failure (#{e.message})")
+        raise
+      else
+        request_logger.info("Success (#{response.status})")
+        response
+      end
+
+      # Executes HTTP request to the API.
+      #
+      # @return [Sawyer::Response]
+      #   Response instance.
+      # @raise [MyApiClient::NetworkError]
+      #   Raises on any network errors.
+      def api_request
+        agent.call(*request_params.to_sawyer_args)
+      rescue *NETWORK_ERRORS => e
+        params = Params::Params.new(request_params, nil)
+        raise MyApiClient::NetworkError.new(params, e)
+      end
+
+      # Verifies the response.
+      #
+      # @param response_params [Sawyer::Response]
+      #   The target response.
+      # @return [nil]
+      #   Returns nil when a valid response.
+      # @raise [MyApiClient::Error]
+      #   Raises on any invalid response.
+      def verify(response_params)
+        params = Params::Params.new(request_params, response_params)
+        find_error_handler(response_params)&.call(params, request_logger)
+      end
+
+      # Executes response verifyment. If an invalid response is detected, return
+      # the error handler procedure. The error handlers defined later takes precedence.
+      #
+      # @param response_params [Sawyer::Response]
+      #   The target response.
+      # @return [nil]
+      #   Returns nil when a valid response.
+      # @return [Proc]
+      #   Returns Proc when a invalid response.
+      def find_error_handler(response_params)
+        instance.error_handlers.reverse_each do |error_handler|
+          result = error_handler.call(instance, response_params)
+          return result unless result.nil?
+        end
+        nil
+      end
+    end
+  end
+end