resteze 0.1.0 → 0.3.0

data/lib/resteze/api_module.rb

@@ -0,0 +1,25 @@
+module Resteze
+  module ApiModule
+    extend ActiveSupport::Concern
+
+    delegate :api_module, :logger, :util, to: :class
+
+    module ClassMethods
+      def api_module
+        @api_module ||=
+          begin
+            parents = name.scan("::").inject([name]) { |mods, _n| mods << mods.last.deconstantize }
+            parents.map(&:constantize).detect { |mod| mod == Resteze || mod.include?(Resteze) }
+          end
+      end
+
+      def logger
+        api_module.logger
+      end
+
+      def util
+        api_module::Util
+      end
+    end
+  end
+end

data/lib/resteze/api_resource.rb

@@ -0,0 +1,70 @@
+module Resteze
+  module ApiResource
+    extend ActiveSupport::Concern
+    include Resteze::Request
+
+    def initialize(id = nil, values: {})
+      super(values)
+      id, @retrieve_params = util.normalize_id(id)
+      self.id = id if self.class.property?(:id)
+    end
+
+    def resource_path
+      unless id.present?
+        raise api_module::InvalidRequestError.new("Could not determine which PATH to request: #{self.class} instance has " \
+                                                  "invalid ID: #{id.inspect}", "id")
+      end
+
+      self.class.resource_path(id)
+    end
+
+    def retrieve_method
+      :get
+    end
+
+    def retrieve_params
+      @retrieve_params || {}
+    end
+
+    def retrieve_headers
+      {}
+    end
+
+    def refresh
+      resp = request(
+        retrieve_method,
+        resource_path,
+        params: retrieve_params,
+        headers: retrieve_headers
+      )
+
+      initialize_from(resp.data)
+    end
+
+    module ClassMethods
+      def service_path
+        api_module.default_service_path(self)
+      end
+
+      def api_version
+        api_module.default_api_version(self)
+      end
+
+      def api_path(path)
+        [service_path, api_version, path].join("/".freeze).squeeze("/".freeze)
+      end
+
+      def resource_slug
+        api_module.default_resource_slug(self)
+      end
+
+      def resource_path(id = nil)
+        api_path([resource_slug, id].compact.map { |part| CGI.escape(part.to_s) }.join("/".freeze))
+      end
+
+      def retrieve(id)
+        new(id).refresh
+      end
+    end
+  end
+end

data/lib/resteze/client.rb

@@ -0,0 +1,242 @@
+module Resteze
+  class Client
+    include Resteze::ApiModule
+
+    def self.user_agent
+      [
+        "Ruby/#{RUBY_VERSION}",
+        "Faraday/#{Faraday::VERSION} (#{faraday_adapter})",
+        "Resteze/#{Resteze::VERSION}",
+        "#{api_module}/#{api_module::VERSION}"
+      ].join(" ")
+    end
+
+    def self.proxy_options
+      return if api_module.try(:proxy).blank?
+
+      Faraday::ProxyOptions.from(api_module.proxy)
+    end
+
+    def self.client_name
+      @client_name ||= to_s.underscore
+    end
+
+    def self.active_client
+      Thread.current[client_name] || default_client
+    end
+
+    def self.default_client
+      Thread.current["#{client_name}_default_client"] ||= new(default_connection)
+    end
+
+    def self.default_connection
+      Thread.current["#{client_name}_default_connection"] ||= Faraday.new do |conn|
+        conn.use Faraday::Request::UrlEncoded
+        conn.use api_module::Middleware::RaiseError
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def self.faraday_adapter
+      @faraday_adapter ||= default_connection.builder.adapter.name.demodulize.underscore
+    end
+
+    # This can be overriden to customize
+    def self.api_url(path = "")
+      [api_module.api_base.chomp("/".freeze), path].join
+    end
+
+    attr_accessor :connection
+
+    delegate :logger,
+             :api_url,
+             :client_name,
+             to: :class
+
+    def initialize(connection = self.class.default_connection)
+      self.connection = connection
+    end
+
+    def request
+      @last_response = nil
+      old_client = Thread.current[client_name]
+      Thread.current[client_name] = self
+      begin
+        res = yield
+        [res, @last_response]
+      ensure
+        Thread.current[client_name] = old_client
+      end
+    end
+
+    # TODO: Look at refactoring this if possible to improve the Abc size
+    # rubocop:disable Metrics/AbcSize
+    def execute_request(method, path, headers: {}, params: {})
+      params = util.objects_to_ids(params)
+      body, query_params = process_params(method, params)
+      headers = request_headers.merge(util.normalize_headers(headers))
+      context = request_log_context(body:, method:, path:, query_params:, headers:)
+
+      http_resp = execute_request_with_rescues(context) do
+        connection.run_request(method, api_url(path), body, headers) do |req|
+          req.options.open_timeout = api_module.open_timeout
+          req.options.timeout      = api_module.read_timeout
+          req.options.proxy        = self.class.proxy_options
+          req.params               = query_params unless query_params.nil?
+        end
+      end
+
+      api_module::Response.from_faraday_response(http_resp).tap do |response|
+        @last_response = response
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    protected
+
+    # Override to customize
+    def request_headers
+      {
+        "User-Agent" => self.class.user_agent,
+        "Accept" => "application/json",
+        "Content-Type" => "application/json"
+      }
+    end
+
+    private
+
+    def process_params(method, params)
+      body = nil
+      query_params = nil
+      case method.to_s.downcase.to_sym
+      when :get, :head, :delete
+        query_params = params
+      else
+        body = params.to_json
+      end
+      [body, query_params]
+    end
+
+    def params_encoder
+      self.class.default_connection.options.params_encoder || Faraday::Utils.default_params_encoder
+    end
+
+    def request_log_context(method: nil, path: nil, query_params: nil, headers: nil, body: nil)
+      RequestLogContext.new.tap do |context|
+        context.method       = method
+        context.path         = path
+        context.query_params = params_encoder.encode(query_params)
+        context.headers      = headers
+        context.body         = body
+      end
+    end
+
+    def execute_request_with_rescues(context)
+      begin
+        request_start = Time.now
+        log_request(context)
+        resp = yield
+        context = context.dup_from_response(resp)
+        log_response(context, request_start, resp)
+      rescue StandardError => e
+        execute_request_rescue_log(e, context, request_start)
+        raise e
+      end
+
+      resp
+    end
+
+    def execute_request_rescue_log(err, context, request_start)
+      if err.respond_to?(:response) && err.response
+        error_context = context.dup_from_response(err.response)
+        log_response(error_context, request_start, err.response)
+      else
+        log_response_error(context, request_start, err)
+      end
+    end
+
+    def log_request(context)
+      logger.info do
+        payload = {
+          method: context.method,
+          path: context.path
+        }
+        "#{self.class} API Request: #{payload}"
+      end
+      logger.debug { request_details_in_http_syntax(context) }
+    end
+
+    def log_response(context, request_start, response)
+      status = response.respond_to?(:status) ? response.status : response[:status]
+      logger.debug { response_details_in_http_syntax(response) }
+      logger.info do
+        payload = {
+          elapsed: Time.now - request_start,
+          method: context.method,
+          path: context.path,
+          status:
+        }
+        "#{self.class} API Response: #{payload}"
+      end
+    end
+
+    def log_response_error(context, request_start, err)
+      logger.error do
+        payload = {
+          elapsed: Time.now - request_start,
+          error_message: err.message,
+          method: context.method,
+          path: context.path
+        }
+        "#{self.class} Request Error: #{payload}"
+      end
+    end
+
+    def request_details_in_http_syntax(context)
+      "#{self.class} Full Request:\n\n".tap do |s|
+        s << request_in_http_syntax(context)
+        s << headers_in_http_syntax(context.headers)
+        s << "\n\n#{context.body}\n" if context.body.present?
+      end
+    end
+
+    # TODO: Look into refactoring to improve Abc Size
+    # rubocop:disable Metrics/AbcSize
+    def response_details_in_http_syntax(response)
+      status  = response.respond_to?(:status)  ? response.status  : response[:status]
+      body    = response.respond_to?(:body)    ? response.body    : response[:body]
+      headers = response.respond_to?(:headers) ? response.headers : response[:headers]
+      "#{self.class} Full Response:\n\n".tap do |s|
+        s << "HTTP/1.1 #{status}\n"
+        s << headers_in_http_syntax(headers)
+        s << "\n\n"
+        s << (body.encoding == Encoding::ASCII_8BIT ? "(Binary Response)" : body)
+        s << "\n"
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def request_in_http_syntax(context)
+      method = context.method.to_s.upcase
+      method.tap do |s|
+        s << " "
+        s << [self.class.api_url(context.path), context.query_params].select(&:present?).join("?")
+        s << "\n"
+      end
+    end
+
+    def headers_in_http_syntax(headers)
+      headers.map { |k, v| [k, v].join(": ") }.join("\n")
+    end
+
+    class RequestLogContext
+      attr_accessor :body, :method, :path, :query_params, :headers
+
+      def dup_from_response(resp)
+        return self if resp.nil?
+
+        dup
+      end
+    end
+  end
+end

data/lib/resteze/errors.rb

@@ -0,0 +1,38 @@
+module Resteze
+  class Error < StandardError
+    attr_accessor :response
+    attr_reader   :message, :code, :http_body, :http_headers, :http_status, :json_body
+
+    # def initialize(message = nil, http_status: nil, http_body: nil, json_body: nil,
+    #                http_headers: nil, code: nil)
+    def initialize(message = nil, **kwargs)
+      super(**kwargs)
+      @message      = message
+      @http_status  = kwargs[:http_status]
+      @http_body    = kwargs[:http_body]
+      @http_headers = kwargs.fetch(:http_headers, {})
+      @json_body    = kwargs[:json_body]
+      @code         = kwargs[:code]
+    end
+
+    def to_s
+      status = "HTTP #{@http_status}:" if @http_status.present?
+      [status, message].compact.join(" ")
+    end
+  end
+
+  class InvalidRequestError < Error
+    attr_accessor :param
+
+    def initialize(message, param, **keyword_args)
+      super(message, **keyword_args)
+      @param = param
+    end
+  end
+
+  class AuthenticationError < Error; end
+
+  class ApiConnectionError < Error; end
+
+  class ApiError < Error; end
+end

data/lib/resteze/list.rb

@@ -0,0 +1,43 @@
+module Resteze
+  module List
+    extend ActiveSupport::Concern
+    include ApiModule
+
+    module ClassMethods
+      def list(params: {})
+        resp = request(list_method, list_resource_path(params), params: list_params(params))
+        construct_list_from(resp.data)
+      end
+
+      def construct_list_from(payload)
+        values = payload.deep_symbolize_keys
+        api_module::ListObject.construct_from(values, self)
+      end
+
+      def construct_empty_list
+        payload = { list_key => [] }
+        construct_list_from(payload)
+      end
+
+      def list_params(params = {})
+        params
+      end
+
+      def list_headers(_params = {})
+        {}
+      end
+
+      def list_resource_path(_params = {})
+        resource_path
+      end
+
+      def list_key
+        api_module.default_list_key(self)
+      end
+
+      def list_method
+        :get
+      end
+    end
+  end
+end

data/lib/resteze/list_object.rb

@@ -0,0 +1,40 @@
+module Resteze
+  module ListObject
+    extend ActiveSupport::Concern
+
+    def metadata
+      @metadata ||= {}
+    end
+
+    def initialize_from(values, metadata: {})
+      @metadata = metadata
+      values.each { |v| self << v }
+      self
+    end
+
+    def as_list_json(list_key)
+      metadata.as_json.merge({ list_key => as_json })
+    end
+
+    module ClassMethods
+      def object_key
+        :_list
+      end
+
+      def construct_from(payload, klass)
+        list_key = klass.list_key
+        payload = payload.deep_symbolize_keys
+        values = util.convert_to_object(payload[list_key], klass)
+        metadata = payload.except(list_key)
+
+        new.initialize_from(values, metadata:)
+      end
+    end
+
+    private
+
+    def populate_metadata(values)
+      @metadata = metadata.merge(values.except(self.class.object_key) || {})
+    end
+  end
+end

data/lib/resteze/middleware/raise_error.rb

@@ -0,0 +1,17 @@
+module Resteze
+  module Middleware
+    class RaiseError < Faraday::Response::RaiseError
+      include Resteze::ApiModule
+
+      def on_complete(env)
+        super
+      rescue Faraday::ConflictError => e
+        raise api_module::ConflictError, e
+      rescue Faraday::UnprocessableEntityError => e
+        raise api_module::UnprocessableEntityError, e
+      rescue Faraday::ResourceNotFound => e
+        raise api_module::ResourceNotFound, e
+      end
+    end
+  end
+end

data/lib/resteze/object.rb

@@ -0,0 +1,73 @@
+module Resteze
+  class Object < Hashie::Trash
+    include Resteze::ApiModule
+    include Hashie::Extensions::DeepMerge
+
+    attr_reader :resteze_metadata, :property_bag
+
+    def initialize(attributes = {}, &)
+      @resteze_metadata = {}
+      @property_bag = {}
+
+      super
+    end
+
+    # This allows us to take advantage of the #property features of
+    # the Hashie::Dash, but also to support unexpected hash values
+    # and store them in the metadata property
+    def []=(property, value)
+      super
+    rescue NoMethodError
+      @property_bag = property_bag.merge({ property => value })
+    end
+
+    def self.class_name
+      name.demodulize
+    end
+
+    def self.object_key
+      api_module.default_object_key(self)
+    end
+
+    def self.construct_from(payload)
+      new.initialize_from(payload)
+    end
+
+    # This is replaced with the idea of Hashie in Channel Advisor
+    def initialize_from(values)
+      values = values.deep_symbolize_keys
+      if self.class.object_key
+        update_attributes(values[self.class.object_key] || {})
+      else
+        update_attributes(values)
+      end
+      populate_metadata(values)
+      self
+    end
+
+    def merge_from(values)
+      values = values.deep_symbolize_keys
+      if self.class.object_key
+        data = values[self.class.object_key] || {}
+        metadata = values.except(self.class.object_key) || {}
+      else
+        data = values
+        metadata = {}
+      end
+
+      deep_merge!(data)
+      @resteze_metadata.deep_merge!(metadata)
+      self
+    end
+
+    def persisted?
+      respond_to?(:id) && id.present?
+    end
+
+    private
+
+    def populate_metadata(values)
+      @resteze_metadata = values.except(self.class.object_key)
+    end
+  end
+end

data/lib/resteze/request.rb

@@ -0,0 +1,14 @@
+module Resteze
+  module Request
+    extend ActiveSupport::Concern
+    include Resteze::ApiModule
+
+    delegate :request, to: :class
+
+    module ClassMethods
+      def request(method, url, params: {}, headers: {})
+        api_module::Client.active_client.execute_request(method, url, params:, headers:)
+      end
+    end
+  end
+end

data/lib/resteze/response.rb

@@ -0,0 +1,52 @@
+module Resteze
+  class Response
+    OK = 200
+    attr_accessor :data, :http_body, :http_headers, :http_status, :request_id
+
+    def self.from_faraday_response(faraday_response)
+      new.tap do |response|
+        response.http_body    = faraday_response.body
+        response.http_headers = faraday_response.headers
+        response.http_status  = faraday_response.status
+        response.request_id   = faraday_response.headers["Request-Id"]
+
+        response.data = parse_body(
+          faraday_response.body,
+          status: response.http_status,
+          headers: response.http_headers
+        )
+      end
+    end
+
+    def self.batch_response?(headers)
+      headers["Content-Type".freeze].to_s.include?("boundary=batchresponse".freeze)
+    end
+
+    def self.parse_body(body, status: nil, headers: {})
+      return body if unparsable_body?(status:, headers:)
+
+      type = mime_type(headers)&.symbol || :json
+      case type
+      when :json
+        JSON.parse(body, symbolize_names: true)
+      when :xml
+        Hash.from_xml(body).deep_symbolize_keys
+      else
+        body
+      end
+    end
+
+    def self.unparsable_body?(status:, headers:)
+      status.to_i == 204 || (300..399).cover?(status.to_i) || batch_response?(headers)
+    end
+
+    def self.mime_type(headers = {})
+      mime_type = headers.transform_keys(&:downcase)["content-type"].to_s.split(";").first.to_s.strip
+      Mime::LOOKUP[mime_type] || Mime::Type.lookup_by_extension(:json)
+    end
+
+    def ok?
+      http_status == OK
+    end
+  end
+end

data/lib/resteze/save.rb

@@ -0,0 +1,35 @@
+module Resteze
+  module Save
+    extend ActiveSupport::Concern
+
+    def save
+      resp = request(
+        save_method,
+        save_resource_path,
+        params: as_save_json,
+        headers: save_headers
+      )
+      process_save_response(resp)
+    end
+
+    def save_method
+      persisted? ? :put : :post
+    end
+
+    def save_resource_path
+      persisted? ? resource_path : self.class.resource_path
+    end
+
+    def as_save_json
+      as_json
+    end
+
+    def save_headers
+      respond_to?(:retrieve_headers) ? retrieve_headers : {}
+    end
+
+    def process_save_response(response)
+      merge_from(response.data)
+    end
+  end
+end

data/lib/resteze/util.rb

@@ -0,0 +1,54 @@
+module Resteze
+  module Util
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def convert_to_object(data, object_class)
+        case data
+        when Array
+          data.map { |i| convert_to_object(i, object_class) }
+        when Hash
+          object_class.construct_from(object_class.object_key.present? ? { object_class.object_key => data } : data)
+        else
+          data
+        end
+      end
+
+      def normalize_headers(headers)
+        headers.transform_keys { |key| capitalize_parts(key) }
+      end
+
+      def normalize_id(id)
+        if id.is_a?(Hash)
+          params_hash = id.dup
+          id = params_hash.delete(:id)
+        else
+          params_hash = {}
+        end
+
+        [id.to_s.presence, params_hash]
+      end
+
+      def objects_to_ids(obj)
+        case obj
+        when ApiResource
+          obj.id
+        when Hash
+          res = {}
+          obj.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
+          res
+        when Array
+          obj.map { |v| objects_to_ids(v) }
+        else
+          obj
+        end
+      end
+
+      def capitalize_parts(str)
+        str.to_s.dasherize.split("-").reject(&:blank?).map(&:capitalize).join("-")
+      end
+    end
+
+    extend ClassMethods
+  end
+end