coinbase_commerce_client 0.1.0

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/badge.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="114" height="20" role="img" aria-label="coverage: 88.92%"><title>coverage: 88.92%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="114" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="53" height="20" fill="#97ca00"/><rect width="114" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="315" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="510">coverage</text><text x="315" y="140" transform="scale(.1)" fill="#fff" textLength="510">coverage</text><text aria-hidden="true" x="865" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="430">88.92%</text><text x="865" y="140" transform="scale(.1)" fill="#fff" textLength="430">88.92%</text></g></svg>

data/lib/coinbase_commerce_client/api_errors.rb

@@ -0,0 +1,150 @@
+module CoinbaseCommerceClient
+  module Errors
+    class APIError < StandardError
+      attr_reader :message, :http_body, :http_headers, :http_status, :json_body, :request_id
+
+      # Response contains a CoinbaseCommerceResponse object
+      attr_accessor :response
+
+      # Initializes a API error.
+      def initialize(message = nil, http_status = nil, http_body = nil, json_body = nil, http_headers = nil)
+        @message = message
+        @http_status = http_status
+        @http_body = http_body
+        @http_headers = http_headers || {}
+        @json_body = json_body
+        @request_id = @http_headers['x-request-id']
+      end
+
+      def to_s
+        status_string = @http_status.nil? ? '' : "(Status #{@http_status}) "
+        id_string = @request_id.nil? ? '' : "(Request #{@request_id}) "
+        "#{status_string}#{id_string}#{@message}"
+      end
+    end
+
+    # in case error connecting to coinbase commerce server
+    class APIConnectionError < APIError
+    end
+
+    # Status 400
+    class BadRequestError < APIError
+    end
+
+    class ParamRequiredError < APIError
+    end
+
+    class InvalidRequestError < APIError
+    end
+
+    # Status 401
+    class AuthenticationError < APIError
+    end
+
+    # Status 404
+    class ResourceNotFoundError < APIError
+    end
+
+    # Status 422
+    class ValidationError < APIError
+    end
+
+    # Status 429
+    class RateLimitExceededError < APIError
+    end
+
+    # Status 500
+    class InternalServerError < APIError
+    end
+
+    # Status 503
+    class ServiceUnavailableError < APIError
+    end
+
+    # Webhook errors
+    class WebhookError < APIError
+      attr_accessor :sig_header
+
+      def initialize(message, sig_header, http_body: nil)
+        super(message, http_body: http_body)
+        @sig_header = sig_header
+      end
+    end
+
+    class SignatureVerificationError < WebhookError
+    end
+
+    class WebhookInvalidPayload < WebhookError
+    end
+
+    # Errors handling
+    def self.handle_error_response(http_resp)
+      begin
+        resp = CoinbaseCommerceClientResponse.from_faraday_hash(http_resp)
+        error_data = resp.data[:error]
+
+        raise APIError, 'Unknown error' unless error_data
+      rescue JSON::ParserError, APIError
+        raise general_api_error(http_resp[:status], http_resp[:body])
+      end
+      error = specific_api_error(resp, error_data)
+      error.response = resp
+      raise(error)
+    end
+
+    def self.general_api_error(status, body)
+      APIError.new("Invalid response object from API: #{body.inspect} " \
+                     "(HTTP response code: #{status} http_body: #{body}")
+    end
+
+    def self.specific_api_error(resp, error_data)
+      opts = {
+        http_body: resp.http_body,
+        http_headers: resp.http_headers,
+        http_status: resp.http_status,
+        json_body: resp.data
+      }
+      case resp.http_status
+      when 400
+        # in case of known error code
+        case error_data[:type]
+        when 'param_required'
+          ParamRequiredError.new(error_data[:message], opts)
+        when 'validation_error'
+          ValidationError.new(error_data[:message], opts)
+        when 'invalid_request'
+          InvalidRequestError.new(error_data[:message], opts)
+        else
+          InvalidRequestError.new(error_data[:message], opts)
+        end
+      when 401
+        AuthenticationError.new(error_data[:message], opts)
+      when 404
+        ResourceNotFoundError.new(error_data[:message], opts)
+      when 429
+        RateLimitExceededError.new(error_data[:message], opts)
+      when 500
+        InternalServerError.new(error_data[:message], opts)
+      when 503
+        ServiceUnavailableError.new(error_data[:message], opts)
+      else
+        APIError.new(error_data[:message], opts)
+      end
+    end
+
+    def self.handle_network_error(e, api_base = nil)
+      api_base ||= @api_uri
+      message = case e
+                when Faraday::ConnectionFailed
+                  'Unexpected error communicating when trying to connect to Coinbase Commerce.'
+                when Faraday::SSLError
+                  'Could not establish a secure connection to Coinbase Commerce.'
+                when Faraday::TimeoutError
+                  "Could not connect to Coinbase Commerce (#{api_base})."
+                else
+                  'Unexpected error communicating with Coinbase Commerce.'
+                end
+      raise APIConnectionError, message + "\n\n(Network error: #{e.message})"
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/base/api_object.rb

@@ -0,0 +1,203 @@
+module CoinbaseCommerceClient
+  module APIResources
+    module Base
+      class APIObject
+        include Enumerable
+
+        def initialize(id = nil, client = nil)
+          @data = {}
+          @data[:id] = id if id
+          @client = client
+          @unsaved_values = Set.new
+          @transient_values = Set.new
+        end
+
+        # Base object options section
+        def [](k)
+          @data[k.to_sym]
+        end
+
+        def []=(k, v)
+          send(:"#{k}=", v)
+        end
+
+        def keys
+          @data.keys
+        end
+
+        def values
+          @data.values
+        end
+
+        def each(&blk)
+          @data.each(&blk)
+        end
+
+        def to_s(*_args)
+          JSON.pretty_generate(to_hash)
+        end
+
+        def to_hash
+          @data.each_with_object({}) do |(key, value), output|
+            case value
+            when Array
+              output[key] = value.map {|v| v.respond_to?(:to_hash) ? v.to_hash : v}
+            else
+              output[key] = value.respond_to?(:to_hash) ? value.to_hash : value
+            end
+          end
+        end
+
+        def to_json(*_a)
+          JSON.generate(@data)
+        end
+
+        def inspect
+          item_id = respond_to?(:id) && !id.nil? ? "id=#{id}" : "No ID"
+          "#{self.class}: #{item_id}> Serialized: " + JSON.pretty_generate(@data)
+        end
+
+        def respond_to_missing?(symbol, include_private = false)
+          @data && @data.key?(symbol) || super
+        end
+
+        def method_missing(name, *args)
+          if name.to_s.end_with?("=")
+
+            attr = name.to_s[0...-1].to_sym
+            val = args.first
+            add_accessors([attr], attr => val)
+
+            begin
+              mth = method(name)
+            rescue NameError
+              raise NoMethodError, "Cannot set #{attr} on this object."
+            end
+
+            return mth.call(args[0])
+
+          elsif @data.key?(name)
+            return @data[name]
+          end
+
+          begin
+            super
+          rescue NoMethodError => e
+            raise unless @transient_values.include?(name)
+            raise NoMethodError, e.message + " Available attributes: #{@data.keys.join(', ')}"
+          end
+        end
+
+        # Object serialize section
+        def serialize_params(options = {})
+          update_hash = {}
+
+          @data.each do |k, v|
+            if options[:push] || @unsaved_values.include?(k) || v.is_a?(APIObject)
+              push = options[:push] || @unsaved_values.include?(k)
+              update_hash[k.to_sym] = serialize_params_value(@data[k], push)
+            end
+          end
+
+          update_hash.reject! {|_, v| v.nil? || v.empty?}
+          update_hash
+        end
+
+        def serialize_params_value(value, push)
+          if value.nil?
+            ""
+          elsif value.is_a?(Array)
+            value.map {|v| serialize_params_value(v, push)}
+
+          elsif value.is_a?(Hash)
+            Util.convert_to_api_object(value, @opts).serialize_params
+
+          elsif value.is_a?(APIObject)
+            value.serialize_params(push: push)
+          else
+            value
+          end
+        end
+
+        # Object initialize/update section
+        def self.create_from(values, client = nil)
+          values = Util.symbolize_names(values)
+          new(values[:id], client).send(:initialize_from, values)
+        end
+
+        def initialize_from(values, partial = false)
+          removed = partial ? Set.new : Set.new(@data.keys - values.keys)
+          added = Set.new(values.keys - @data.keys)
+
+          remove_accessors(removed)
+          add_accessors(added, values)
+
+          removed.each do |k|
+            @data.delete(k)
+            @transient_values.add(k)
+            @unsaved_values.delete(k)
+          end
+
+          update_attributes(values)
+          values.each_key do |k|
+            @transient_values.delete(k)
+            @unsaved_values.delete(k)
+          end
+
+          self
+        end
+
+        def update_attributes(values)
+          values.each do |k, v|
+            add_accessors([k], values) unless metaclass.method_defined?(k.to_sym)
+            @data[k] = Util.convert_to_api_object(v, @client)
+            @unsaved_values.add(k)
+          end
+        end
+
+
+        protected
+
+        def metaclass
+          class << self
+            self
+          end
+        end
+
+        def remove_accessors(keys)
+          metaclass.instance_eval do
+            keys.each do |k|
+              # Remove methods for the accessor's reader and writer.
+              [k, :"#{k}=", :"#{k}?"].each do |method_name|
+                remove_method(method_name) if method_defined?(method_name)
+              end
+            end
+          end
+        end
+
+        def add_accessors(keys, values)
+          metaclass.instance_eval do
+            keys.each do |k|
+              if k == :method
+                define_method(k) {|*args| args.empty? ? @data[k] : super(*args)}
+              else
+                define_method(k) {@data[k]}
+              end
+
+              define_method(:"#{k}=") do |v|
+                if v != ""
+                  @data[k] = Util.convert_to_api_object(v, @opts)
+                  @unsaved_values.add(k)
+                end
+              end
+
+              if [FalseClass, TrueClass].include?(values[k].class)
+                define_method(:"#{k}?") {@data[k]}
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/base/api_resource.rb

@@ -0,0 +1,23 @@
+module CoinbaseCommerceClient
+  module APIResources
+    module Base
+      class APIResource < APIObject
+        class << self
+          attr_accessor :client
+        end
+
+        @client = nil
+
+        def self.retrieve(id, params = {})
+          resp = @client.request(:get, "#{self::RESOURCE_PATH}/#{id}", params)
+          Util.convert_to_api_object(resp.data, @client, self)
+        end
+
+        def refresh(params = {})
+          resp = @client.request(:get, "#{self.class::RESOURCE_PATH}/#{self[:id]}", params)
+          initialize_from(resp.data)
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/base/create.rb

@@ -0,0 +1,12 @@
+module CoinbaseCommerceClient
+  module APIResources
+    module Base
+      module Create
+        def create(params = {})
+          response = @client.request(:post, "#{self::RESOURCE_PATH}", params)
+          Util.convert_to_api_object(response.data, @client, self)
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/base/delete.rb

@@ -0,0 +1,13 @@
+module CoinbaseCommerceClient
+  module APIResources
+    module Base
+      module Delete
+        def delete
+          response = @client.request(:delete, "#{self.class::RESOURCE_PATH}/#{self[:id]}")
+          initialize_from(response.data)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/base/list.rb

@@ -0,0 +1,23 @@
+module CoinbaseCommerceClient
+  module APIResources
+    module Base
+      module List
+        def list(params = {})
+          resp = @client.request(:get, self::RESOURCE_PATH.to_s, params)
+          Util.convert_to_api_object(resp.data, @client, self)
+        end
+
+        def auto_paging(params = {}, &blk)
+          loop do
+            page = list(params)
+            last_id = page.data.empty? ? nil : page.data.last.id
+            break if last_id.nil?
+
+            params[:starting_after] = last_id
+            page.data.each(&blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/base/save.rb

@@ -0,0 +1,15 @@
+module CoinbaseCommerceClient
+  module APIResources
+    module Base
+      module Save
+        def save
+          values = serialize_params(self)
+          values.delete(:id)
+          resp = @client.request(:put, "#{self.class::RESOURCE_PATH}/#{self[:id]}", self)
+          initialize_from(resp.data)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/base/update.rb

@@ -0,0 +1,12 @@
+module CoinbaseCommerceClient
+  module APIResources
+    module Base
+      module Update
+        def modify(id, params={})
+          resp = @client.request(:put, "#{self::RESOURCE_PATH}/#{id}", params)
+          Util.convert_to_api_object(resp.data, @client, self)
+        end
+      end
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/charge.rb

@@ -0,0 +1,11 @@
+module CoinbaseCommerceClient
+  module APIResources
+    class Charge < Base::APIResource
+      extend Base::List
+      extend Base::Create
+
+      OBJECT_NAME = 'charge'.freeze
+      RESOURCE_PATH = 'charges'.freeze
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/checkout.rb

@@ -0,0 +1,15 @@
+module CoinbaseCommerceClient
+  module APIResources
+    class Checkout < Base::APIResource
+      extend Base::List
+      extend Base::Create
+      extend Base::Update
+
+      include Base::Save
+      include Base::Delete
+
+      OBJECT_NAME = 'checkout'.freeze
+      RESOURCE_PATH = 'checkouts'.freeze
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_resources/event.rb

@@ -0,0 +1,10 @@
+module CoinbaseCommerceClient
+  module APIResources
+    class Event < Base::APIResource
+      extend Base::List
+
+      OBJECT_NAME = 'event'.freeze
+      RESOURCE_PATH = 'events'.freeze
+    end
+  end
+end

data/lib/coinbase_commerce_client/api_response.rb

@@ -0,0 +1,36 @@
+module CoinbaseCommerceClient
+  class CoinbaseCommerceClientResponse
+    attr_accessor :data, :http_body, :http_headers, :http_status, :request_id
+
+    # Initializes a CoinbaseCommerceResponse object
+    # from a Hash like the kind returned as part of a Faraday exception.
+    def self.from_faraday_hash(http_resp)
+      resp = CoinbaseCommerceClientResponse.new
+      resp.data = JSON.parse(http_resp[:body], symbolize_names: true)
+      resp.http_body = http_resp[:body]
+      resp.http_headers = http_resp[:headers]
+      resp.http_status = http_resp[:status]
+      resp.request_id = http_resp[:headers]['x-request-id']
+      resp
+    end
+
+    # Initializes a CoinbaseCommerceResponse object
+    # from a Faraday HTTP response object.
+    def self.from_faraday_response(http_resp)
+      resp = CoinbaseCommerceClientResponse.new
+      resp.data = JSON.parse(http_resp.body, symbolize_names: true)
+      resp.http_body = http_resp.body
+      resp.http_headers = http_resp.headers
+      resp.http_status = http_resp.status
+      resp.request_id = http_resp.headers['x-request-id']
+
+      # unpack nested data field if it exist
+      resp.data.update(resp.data.delete(:data)) if resp.data.is_a?(Hash) && resp.data.fetch(:data, nil).is_a?(Hash)
+
+      # warn in there warnings in response
+      warn(resp.data[:warnings].first.to_s) if resp.data.is_a?(Hash) && resp.data.fetch(:warnings, nil).is_a?(Array)
+
+      resp
+    end
+  end
+end

data/lib/coinbase_commerce_client/client.rb

@@ -0,0 +1,115 @@
+module CoinbaseCommerceClient
+  BASE_API_URL = 'https://api.commerce.coinbase.com/'.freeze
+  API_VERSION = '2018-03-22'.freeze
+
+  class Client
+    def initialize(options = {})
+      check_api_key!(options[:api_key])
+      @api_key = options[:api_key]
+      @api_uri = URI.parse(options[:api_url] || BASE_API_URL)
+      @api_ver = options[:api_ver] || API_VERSION
+
+      @conn = Faraday.new do |c|
+        c.use Faraday::Request::UrlEncoded
+        c.use Faraday::Response::RaiseError
+        c.adapter Faraday.default_adapter
+      end
+    end
+
+    def charge
+      APIResources::Charge.client = self
+      APIResources::Charge
+    end
+
+    def checkout
+      APIResources::Checkout.client = self
+      APIResources::Checkout
+    end
+
+    def event
+      APIResources::Event.client = self
+      APIResources::Event
+    end
+
+    def api_url(url = "", api_base = nil)
+      (api_base || CoinbaseCommerceClient::BASE_API_URL) + url
+    end
+
+    def request_headers(api_key)
+      {
+        "User-Agent" => "CoinbaseCommerce/#{CoinbaseCommerceClient::VERSION}",
+        "Accept" => "application/json",
+        "X-CC-Api-Key" => api_key,
+        "X-CC-Version" => @api_ver,
+        "Content-Type" => "application/json",
+      }
+    end
+
+    def check_api_key!(api_key)
+      raise AuthenticationError, 'No API key provided' unless api_key
+    end
+
+    def request(method, path, params = {})
+      @last_response = nil
+      url = api_url(path, @api_uri)
+      headers = request_headers(@api_key)
+
+      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
+
+      u = URI.parse(path)
+      unless u.query.nil?
+        query_params ||= {}
+        query_params = Hash[URI.decode_www_form(u.query)].merge(query_params)
+      end
+
+
+      http_resp = execute_request_with_rescues(@api_uri) do
+        @conn.run_request(method, url, body, headers) do |req|
+          req.params = query_params unless query_params.nil?
+        end
+      end
+
+      begin
+        resp = CoinbaseCommerceClientResponse.from_faraday_response(http_resp)
+      rescue JSON::ParserError
+        raise Errors.general_api_error(http_resp.status, http_resp.body)
+      end
+
+      @last_response = resp
+      resp
+    end
+
+    def execute_request_with_rescues(api_base)
+      begin
+        resp = yield
+      rescue StandardError => e
+        case e
+        when Faraday::ClientError
+          if e.response
+            Errors.handle_error_response(e.response)
+          else
+            Errors.handle_network_error(e, api_base)
+          end
+        when Faraday::ServerError
+          if e.response
+            Errors.handle_error_response(e.response)
+          else
+            Errors.handle_network_error(e, api_base)
+          end
+        else
+          raise
+        end
+      end
+      resp
+    end
+
+  end
+end