cash_app_pay 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 56ca23a3952f68fcf4c16941a887ee4a66016774074405b6cadcc5ce63cc8168
+  data.tar.gz: 57edbf0f525f96d03da5e838b31192472bd9dc643b49cc6514dd5e227e93329e
+SHA512:
+  metadata.gz: 8cb314461eea62e42789ffc4a0de5ddd88d1c6b45c64ec30575e0f9ff36e996852cb2d3717fa46de7de492928cfc980ce26ee6edbc60aded6d7c4101816d1b16
+  data.tar.gz: 0755fbff98ba362c1756e23420701f7c2a186dec0fb210bb259db713267b86303ed7e5ca578535236b1ed6e95a07af713f511a5f20dc06ed1ad649a36ac5e2bf

data/lib/cash_app_pay/api_operations/create.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module APIOperations
+    module Create
+      def create(params = {}, opts = {})
+        request_cash_app_pay_object(
+          method: :post,
+          path: resource_url,
+          params: params,
+          opts: opts
+        )
+      end
+    end
+  end
+end

data/lib/cash_app_pay/api_operations/delete.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module APIOperations
+    module Delete
+      def delete(opts = {})
+        delete_cash_app_pay_object(
+          path: resource_url,
+          opts: opts
+        )
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def delete(resource, _params = {}, opts = {})
+          delete_cash_app_pay_object(
+            path: "#{resource_url}/#{CGI.escape(resource)}",
+            opts: opts
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cash_app_pay/api_operations/list.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module APIOperations
+    module List
+      def list(filters = {}, opts = {})
+        response, opts = execute_resource_request(
+          method: :get,
+          url: resource_url,
+          url_params: filters,
+          opts: opts
+        )
+        ListObject.initialize_from_response(self, response, opts, filters)
+      end
+    end
+  end
+end

data/lib/cash_app_pay/api_operations/request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module APIOperations
+    module Request
+      def request_cash_app_pay_object(method:, path:, params:, opts: {})
+        body = self.class.encode_body(params) unless params.nil?
+        response, opts = self.class.execute_resource_request(method: method, url: path, body_params: body, opts: opts)
+        initialize_from(response.data, opts)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      private
+
+      def delete_cash_app_pay_object(path:, opts: {})
+        response, = execute_resource_request(method: :delete, url: path, opts: opts)
+        response.http_status == 200
+      end
+
+      module ClassMethods
+        def execute_resource_request(method:, url:, url_params: nil, body_params: nil, opts: {})
+          response = CashAppPay::CashAppPayClient.execute_request(method_name: method, path: url,
+                                                                  url_params: url_params, body_params: body_params, opts: opts)
+          [response, opts]
+        end
+
+        def request_cash_app_pay_object(method:, path:, params:, opts: {})
+          body = encode_body(params) unless params.nil?
+          response, opts = execute_resource_request(method: method, url: path, body_params: body, opts: opts)
+          initialize_from_net_response(response, opts)
+        end
+
+        private
+
+        def delete_cash_app_pay_object(path:, opts: {})
+          response, = execute_resource_request(method: :delete, url: path, opts: opts)
+          response.http_status == 200
+        end
+      end
+    end
+  end
+end

data/lib/cash_app_pay/api_operations/retrieve.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module APIOperations
+    module Retrieve
+      def refresh
+        response, opts = self.class.execute_resource_request(method: :get, url: resource_url, opts: @opts)
+        initialize_from(response.data, opts)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def retrieve(id, opts = {})
+          instance = new({ id: id }, opts)
+          instance.refresh
+          instance
+        end
+      end
+    end
+  end
+end

data/lib/cash_app_pay/api_operations/save.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module APIOperations
+    module Save
+      def save(opts = {})
+        request_cash_app_pay_object(
+          method: :post,
+          path: self.class.resource_url,
+          params: @values,
+          opts: opts
+        )
+      end
+    end
+  end
+end

data/lib/cash_app_pay/api_operations/update.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module APIOperations
+    module Update
+      def update(params = {}, opts = {})
+        request_cash_app_pay_object(
+          method: :patch,
+          path: resource_url,
+          params: params,
+          opts: opts
+        )
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def update(resource, params = {}, opts = {})
+          request_cash_app_pay_object(
+            method: :patch,
+            path: "#{resource_url}/#{CGI.escape(resource)}",
+            params: params,
+            opts: opts
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cash_app_pay/api_operations/upsert.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module APIOperations
+    module Upsert
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def upsert(resource, params = {}, opts = {})
+          request_cash_app_pay_object(
+            method: :put,
+            path: "#{resource_url}/#{CGI.escape(resource)}",
+            params: params,
+            opts: opts
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cash_app_pay/api_resource.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  class APIResource < CashAppPayObject
+    include CashAppPay::APIOperations::Request
+
+    attr_reader :opts
+
+    def initialize(values = {}, opts = {})
+      super(values)
+      @opts = opts
+    end
+
+    def self.resource_url
+      raise NotImplementedError, 'API Resource is an abstract class'
+    end
+
+    private
+
+    def self.initialize_from_net_response(response, opts)
+      instance = new
+      instance.send(:initialize_from, response.data, opts)
+      instance
+    end
+
+    def initialize_from(values, opts)
+      @values = values.fetch(self.class.object_name, {})
+      @opts = opts
+      self
+    end
+
+    def resource_url
+      unless (id = self.id)
+        raise InvalidRequestError.new(
+          "Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}",
+          'id'
+        )
+      end
+      "#{self.class.resource_url}/#{CGI.escape(id)}"
+    end
+
+    # Encode the params for the body of the request.
+    # If the params contains `idempotency_key` then put this at the root
+    # e.g. { request: { id: 1 }, idempotency_key: 'key' }
+    # params: Hash of params
+    def self.encode_body(params)
+      idempotency_key = params.delete(:idempotency_key) || params.delete('idempotency_key')
+      body = if params.empty? && !idempotency_key.nil?
+               { idempotency_key: idempotency_key }
+             else
+               named_body_params = Hash[object_name, params]
+               named_body_params[:idempotency_key] = idempotency_key unless idempotency_key.nil?
+               named_body_params
+             end
+      body.to_json
+    end
+  end
+end

data/lib/cash_app_pay/cash_app_pay_client.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'cash_app_pay/version'
+
+module CashAppPay
+  class CashAppPayClient
+    def self.execute_request(method_name:, path:, url_params:, body_params: nil, opts: {})
+      base_uri = opts[:api_base] || CashAppPay.api_base
+      client_id = opts[:client_id] || CashAppPay.client_id
+
+      check_client_id!(client_id)
+
+      method = method_name.to_s.upcase
+      url = URI::HTTPS.build(host: base_uri, path: path)
+      url.query = URI.encode_www_form(url_params) if !url_params.nil? && !url_params.empty?
+      http = CashAppPay::PersistentHttpClient.get(url)
+
+      headers = if path.start_with?(NETWORK_API_PATH_PREFIX) || path.start_with?(MANAGE_API_PATH_PREFIX)
+                  network_api_headers(client_id, opts)
+                elsif path.start_with?(CUSTOMER_REQUEST_API_PATH_PREFIX)
+                  customer_request_api_headers(client_id)
+                else
+                  raise InvalidRequestError.new('path', '')
+                end
+
+      request = Net::HTTPGenericRequest.new(method, !body_params.nil?, true, url, headers)
+      request.body = body_params unless body_params.nil?
+
+      response = http.request(request)
+
+      begin
+        resp = CashAppPayResponse.from_net_http(response)
+        handle_error_response(resp.error_data) if resp.error_data
+      rescue JSON::ParserError
+        raise general_api_error(response.code.to_i, response.body)
+      end
+
+      resp
+    end
+
+    def self.handle_error_response(response_errors)
+      return unless (error_response = response_errors.first)
+
+      raise APIResponseError, error_response
+    end
+
+    def self.check_client_id!(client_id)
+      return if client_id
+
+      raise AuthenticationError, 'No Client ID provided. Set your API key using CashAppPay.client_id = <CLIENT-ID>'
+    end
+
+    def self.check_api_base!(api_base)
+      return if api_base
+
+      raise AuthenticationError, 'No API base provided. Set your API key using CashAppPay.api_base = <API-BASE>'
+    end
+
+    def self.check_region!(region)
+      raise AuthenticationError, 'No Region provided. Set your API key using CashAppPay.region = <REGION>' unless region
+    end
+
+    def self.check_signature!(signature)
+      return if signature
+
+      raise AuthenticationError, 'No Signature provided. Set your API key using CashAppPay.signature = <SIGNATURE>'
+    end
+
+    def self.check_api_key!(api_key)
+      return if api_key
+
+      raise AuthenticationError, 'No Region provided. Set your API key using CashAppPay.api_key = <API-KEY>'
+    end
+
+    def self.general_api_error(status, body)
+      APIError.new("Invalid response object from API: #{body.inspect} (HTTP response code was #{status})",
+                   http_status: status, http_body: body)
+    end
+
+    def self.user_agent
+      "cash-app-pay-ruby/v#{CashAppPay::VERSION} RubyBindings (#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})) RUBY_PLATFORM #{defined?(RUBY_ENGINE) ? "(#{RUBY_ENGINE})" : ''}"
+    end
+
+    CUSTOMER_REQUEST_API_PATH_PREFIX = '/customer-request/'
+    NETWORK_API_PATH_PREFIX = '/network/'
+    MANAGE_API_PATH_PREFIX = '/management/'
+
+    def self.customer_request_api_headers(client_id)
+      {
+        "Authorization": ['Client', client_id].join(' '),
+        "Accept": 'application/json',
+        "Content-Type": 'application/json',
+        "User-Agent": user_agent
+      }
+    end
+
+    def self.network_api_headers(client_id, opts)
+      api_key = opts[:api_key] || CashAppPay.api_key
+      signature = opts[:signature] || CashAppPay.signature
+      region = opts[:region] || CashAppPay.region
+
+      check_api_key!(api_key)
+      check_signature!(signature)
+      check_region!(region)
+
+      authorization = ['Client', client_id, api_key].join(' ')
+      {
+        "Authorization": authorization,
+        "X-Region": region,
+        "X-Signature": signature,
+        "Accept": 'application/json',
+        "Content-Type": 'application/json',
+        "User-Agent": user_agent
+      }
+    end
+  end
+end

data/lib/cash_app_pay/cash_app_pay_configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'cash_app_pay/endpoint'
+
+module CashAppPay
+  class CashAppPayConfiguration
+    attr_accessor :client_id, :api_base, :region, :signature, :api_key
+
+    def self.setup
+      new.tap do |instance|
+        yield(instance) if block_given?
+      end
+    end
+
+    def initialize
+      @api_base = Endpoint::PRODUCTION
+    end
+  end
+end

data/lib/cash_app_pay/cash_app_pay_object.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  class CashAppPayObject
+    using CashAppPay::Helpers::Symbolize
+
+    attr_accessor :values
+
+    def initialize(values)
+      @values = values.deep_symbolize_keys
+    end
+
+    def to_h(*_args)
+      @values
+    end
+
+    alias to_hash to_h
+    alias as_json to_h
+
+    def to_json(*_args)
+      @values.to_json
+    end
+
+    def to_s(*_args)
+      JSON.pretty_generate(to_h)
+    end
+
+    def to_str
+      self['id'].to_s
+    end
+
+    def inspect
+      id_string = !id.nil? ? " id=#{id}" : ''
+      "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " +
+        JSON.pretty_generate(@values)
+    end
+
+    def [](name)
+      data = @values[typed_key(name)]
+      if data.is_a?(Hash)
+        CashAppPay::CashAppPayObject.new(data)
+      elsif data.is_a?(Array)
+        data.map do |item|
+          item.is_a?(Hash) ? CashAppPay::CashAppPayObject.new(item) : item
+        end
+      else
+        data
+      end
+    end
+
+    def ==(other)
+      if other.is_a?(CashAppPay::CashAppPayObject)
+        @values == other.values
+      else
+        false
+      end
+    end
+
+    def []=(name, value)
+      @values[typed_key(name)] = value
+    end
+
+    def method_missing(name, *_args)
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        val = _args.first
+        self[attr] = val
+      else
+        self[name]
+      end
+    end
+
+    def typed_key(key)
+      key.to_sym
+    end
+  end
+end

data/lib/cash_app_pay/cash_app_pay_response.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  class CashAppPayResponse
+    attr_accessor :http_headers, :http_status, :data, :error_data, :http_body
+
+    def self.from_net_http(http_resp)
+      resp = CashAppPayResponse.new
+      resp.http_headers = http_resp.each_header.to_h
+      resp.http_status = http_resp.code.to_i
+      resp.http_body = http_resp.body
+      resp.data = JSON.parse(http_resp.read_body, symbolize_names: true) unless resp.http_body.empty?
+      resp.error_data = resp&.data&.fetch(:errors, nil)
+      resp
+    end
+  end
+end

data/lib/cash_app_pay/connection_manager.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# connection manager represents
+# a cache of all keep-alive connections
+# in a current thread
+module CashAppPay
+  class ConnectionManager
+    DEFAULT_OPTIONS = { read_timeout: 80, open_timeout: 30 }.freeze
+    # if a client wasn't used within this time range
+    # it gets removed from the cache and the connection closed.
+    # This helps to make sure there are no memory leaks.
+    STALE_AFTER = 60 * 5 # 5.minutes
+
+    # Seconds to reuse the connection of the previous request. If the idle time is less than this Keep-Alive Timeout, Net::HTTP reuses the TCP/IP socket used by the previous communication. Source: Ruby docs
+    KEEP_ALIVE_TIMEOUT = 30 # seconds
+
+    # KEEP_ALIVE_TIMEOUT vs STALE_AFTER
+    # STALE_AFTER - how long an Net::HTTP client object is cached in ruby
+    # KEEP_ALIVE_TIMEOUT - how long that client keeps TCP/IP socket open.
+
+    attr_accessor :clients_store, :last_used
+
+    def initialize
+      self.clients_store = {}
+      self.last_used = Time.now
+    end
+
+    def get_client(uri, options)
+      mutex.synchronize do
+        # refresh the last time a client was used,
+        # this prevents the client from becoming stale
+        self.last_used = Time.now
+
+        # we use params as a cache key for clients.
+        # 2 connections to the same host but with different
+        # options are going to use different HTTP clients
+        params = [uri.host, uri.port, options]
+        client = clients_store[params]
+
+        return client if client
+
+        client = Net::HTTP.new(uri.host, uri.port)
+        client.keep_alive_timeout = KEEP_ALIVE_TIMEOUT
+
+        # set SSL to true if a scheme is https
+        client.use_ssl = uri.scheme == 'https'
+
+        # dynamically set Net::HTTP options
+        DEFAULT_OPTIONS.merge(options).each_pair do |key, value|
+          client.public_send("#{key}=", value)
+        end
+
+        # open connection
+        client.start
+
+        # cache the client
+        clients_store[params] = client
+
+        client
+      end
+    end
+
+    # close connections for each client
+    def close_connections!
+      mutex.synchronize do
+        clients_store.each_value(&:finish)
+        self.clients_store = {}
+      end
+    end
+
+    def stale?
+      Time.now - last_used > STALE_AFTER
+    end
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+  end
+end

data/lib/cash_app_pay/endpoint.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module Endpoint
+    SANDBOX = 'sandbox.api.cash.app'
+    PRODUCTION = 'api.cash.app'
+  end
+end

data/lib/cash_app_pay/error_object.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  class ErrorObject < CashAppPayObject
+  end
+end

data/lib/cash_app_pay/errors.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  # CashAppPayError is the base error from which all other more specific errors derive.
+  class CashAppPayError < StandardError
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+  end
+
+  # InvalidRequestError is raised when a request is initiated with invalid
+  # parameters.
+  class InvalidRequestError < CashAppPayError
+    attr_accessor :param
+
+    def initialize(message, param)
+      super(message)
+      @param = param
+    end
+  end
+
+  # AuthenticationError is raised when invalid credentials are used to connect
+  # to Cash App servers.
+  class AuthenticationError < CashAppPayError
+  end
+
+  class APIError < CashAppPayError
+    attr_reader :http_status, :http_body
+
+    def initialize(message, http_status:, http_body:)
+      super(message)
+      @http_status = http_status
+      @http_body = http_body
+    end
+  end
+
+  class APIResponseError < CashAppPayError
+    def initialize(response)
+      error_object = ErrorObject.new(response)
+      super(error_object.to_s)
+    end
+  end
+end

data/lib/cash_app_pay/helpers/symbolize.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CashAppPay
+  module Helpers
+    module Symbolize
+      extend self
+
+      def symbolize_recursive(hash)
+        {}.tap do |h|
+          hash.each { |key, value| h[key.to_sym] = transform(value) }
+        end
+      end
+
+      private
+
+      def transform(thing)
+        case thing
+        when Hash then symbolize_recursive(thing)
+        when Array then thing.map { |v| transform(v) }
+        else; thing
+        end
+      end
+
+      refine Hash do
+        def deep_symbolize_keys
+          Symbolize.symbolize_recursive(self)
+        end
+      end
+    end
+  end
+end