justifi 0.5.0

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "justifi"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/justifi.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/justifi/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "justifi"
+  spec.version = Justifi::VERSION
+  spec.authors = ["JustiFi"]
+  spec.email = ["support@justifi.ai"]
+
+  spec.summary = "JustiFi API wrapper gem"
+  spec.description = "Used to communicate with JustiFi APIs"
+  spec.homepage = "https://justifi.ai"
+  spec.required_ruby_version = ">= 2.4"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/justifi-tech/justifi-ruby"
+  spec.metadata["github_repo"] = "ssh://github.com/justifi-tech/justifi-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/justifi-tech/justifi-ruby/changelog"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features|gem)/}) }
+  end
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "dotenv"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "standard"
+  spec.add_development_dependency "webmock", ">= 3.8.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-small-badge"
+end

data/lib/justifi/api_operations.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Justifi
+  module APIOperations
+    module ClassMethods
+      def execute_post_request(path, body, headers)
+        raise ArgumentError, "body should be a string" if body && !body.is_a?(String)
+        raise ArgumentError, "headers should be a hash" if headers && !headers.is_a?(Hash)
+
+        response = execute_request(:post, path, body, headers)
+
+        JustifiObject.construct_from(path, response, headers)
+      end
+
+      def execute_get_request(path, query, headers)
+        raise ArgumentError, "query should be a string" if query && !query.is_a?(String)
+        raise ArgumentError, "headers should be a hash" if headers && !headers.is_a?(Hash)
+
+        path = "#{path}?#{query}"
+        response = execute_request(:get, path, nil, headers)
+
+        JustifiObject.construct_from(path, response, headers)
+      end
+
+      def execute_patch_request(path, body, headers)
+        raise ArgumentError, "body should be a string" if body && !body.is_a?(String)
+        raise ArgumentError, "headers should be a hash" if headers && !headers.is_a?(Hash)
+
+        response = execute_request(:patch, path, body, headers)
+
+        JustifiObject.construct_from(path, response, headers)
+      end
+
+      def idempotently_request(path, method:, params:, headers:, idempotency_key: nil)
+        idempotency_key ||= Justifi.get_idempotency_key
+        headers[:idempotency_key] = idempotency_key
+
+        retryable_request do
+          send("execute_#{method}_request", path, params, headers)
+        end
+      end
+
+      private def execute_request(method_name, path, body, headers)
+        headers["Content-Type"] = "application/json"
+        headers["User-Agent"] = "justifi-ruby-#{Justifi::VERSION}"
+
+        connection = http_connection(path)
+
+        method_name = method_name.to_s.upcase
+        has_response_body = method_name != "HEAD"
+        request = Net::HTTPGenericRequest.new(
+          method_name,
+          (body ? true : false),
+          has_response_body,
+          path,
+          headers
+        )
+
+        response = JustifiResponse.from_net_http(connection.request(request, body))
+        raise InvalidHttpResponseError.new(response: response) unless response.success
+        response
+      end
+
+      private def retryable_request
+        attempt = 1
+
+        begin
+          response = yield
+        rescue => e
+          if should_retry?(e, attempt: attempt)
+            attempt += 1
+            retry
+          end
+
+          raise
+        end
+
+        response
+      end
+
+      private def should_retry?(error, attempt:)
+        return false if attempt >= Justifi.max_attempts
+
+        case error
+        when Net::OpenTimeout, Net::ReadTimeout
+          true
+        when Justifi::Error
+          # 409 Conflict
+          return true if error.response_code == 409
+          # Add more cases
+        else
+          false
+        end
+      end
+
+      def http_connection(path)
+        uri = URI("#{Justifi.api_url}#{path}")
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true)
+      end
+    end
+  end
+end

data/lib/justifi/configuration.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Justifi
+  class Configuration
+    API_BASE_URL = "https://api.justifi.ai"
+
+    attr_accessor :client_id
+    attr_accessor :client_secret
+    attr_accessor :access_token
+    attr_accessor :environment
+    attr_accessor :max_attempts
+    attr_accessor :cache
+
+    def self.setup
+      new.tap do |instance|
+        yield(instance) if block_given?
+      end
+    end
+
+    def initialize
+      @max_attempts = 3
+    end
+
+    def credentials
+      raise Justifi::BadCredentialsError, "credentials not set" if bad_credentials?
+
+      {
+        client_id: client_id,
+        client_secret: client_secret
+      }
+    end
+
+    def bad_credentials?
+      # TODO: improve this
+      return true if client_id.nil? || client_secret.nil?
+    end
+
+    def clear_credentials
+      @client_id = nil
+      @client_secret = nil
+    end
+
+    def api_url
+      case environment
+      when "staging"
+        ENV["API_STAGING_BASE_URL"]
+      else
+        API_BASE_URL
+      end
+    end
+
+    def use_production
+      @environment = "production"
+    end
+
+    def use_staging
+      @environment = "staging"
+    end
+  end
+end

data/lib/justifi/dispute.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Justifi
+  module Dispute
+    class << self
+      def list(params: {}, headers: {}, seller_account_id: nil)
+        headers[:seller_account] = seller_account_id if seller_account_id
+        JustifiOperations.execute_get_request("/v1/disputes", params, headers)
+      end
+
+      def get(dispute_id:, headers: {})
+        JustifiOperations.execute_get_request("/v1/disputes/#{dispute_id}",
+          {},
+          headers)
+      end
+
+      def update(dispute_id:, params: {}, headers: {}, idempotency_key: nil)
+        JustifiOperations.idempotently_request("/v1/disputes/#{dispute_id}",
+          method: :patch,
+          params: params,
+          headers: {})
+      end
+    end
+  end
+end

data/lib/justifi/in_memory_cache.rb

@@ -0,0 +1,54 @@
+module Justifi
+  class InMemoryCache
+    attr_reader :data
+
+    HALF_DAY_IN_SECONDS = 43200
+
+    def initialize
+      @data = {}
+    end
+
+    # preload data into the cache
+    def init(data)
+      data.map do |key, value|
+        set(key, value)
+      end
+    end
+
+    def set(key, value, expiration: nil)
+      expiration ||= Time.now + HALF_DAY_IN_SECONDS
+      @data[key.to_s] = expirable_value(value, expiration)
+    end
+
+    def set_and_return(key, value, expiration: nil)
+      set(key, value, expiration: expiration)
+      value
+    end
+
+    def expirable_value(value, expiration)
+      {value: value, expiration: expiration}
+    end
+
+    def get(key)
+      expire_key!(key) if expired?(@data[key.to_s]&.fetch(:expiration))
+      @data[key.to_s]&.fetch(:value)
+    end
+
+    def get_expiration(key)
+      expire_key!(key) if expired?(@data[key.to_s]&.fetch(:expiration))
+      @data[key.to_s]&.fetch(:expiration)
+    end
+
+    def expired?(expiration)
+      !expiration.nil? && Time.now > expiration
+    end
+
+    def expire_key!(key)
+      @data.delete(key.to_s)
+    end
+
+    def clear_cache
+      @data = {}
+    end
+  end
+end

data/lib/justifi/justifi_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Justifi
+  class Error < StandardError
+    attr_reader :response_code
+
+    def initialize(response_code, msg)
+      super(msg)
+      @response_code = response_code
+    end
+  end
+
+  class InvalidHttpResponseError < Error
+    def initialize(response:)
+      super(response.http_status, response.error_message)
+    end
+  end
+end

data/lib/justifi/justifi_object.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Justifi
+  class JustifiObject
+    extend Justifi::JustifiOperations
+
+    attr_reader :raw_response, :id, :headers
+
+    def initialize(id: nil, headers: {}, raw_response: nil)
+      @id = id
+      @headers = Util.normalize_headers(headers)
+      @raw_response = raw_response
+    end
+
+    def self.construct_from(path, response, headers = {})
+      values = response.is_a?(JustifiResponse) ? response.data : response
+
+      new(id: values[:id], raw_response: response)
+        .send(:initialize_from, values, headers)
+    end
+
+    protected def initialize_from(values, headers)
+      values.each do |k, v|
+        instance_variable_set("@#{k}", v.is_a?(Hash) ? OpenStruct.new(v) : v)
+        self.class.send(:define_method, k, proc { instance_variable_get("@#{k}") })
+        self.class.send(:define_method, "#{k}=", proc { |v| instance_variable_set("@#{k}", v) })
+      end
+
+      @headers = Util.normalize_headers(headers)
+
+      self
+    end
+  end
+end

data/lib/justifi/justifi_operations.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Justifi
+  module JustifiOperations
+    extend APIOperations::ClassMethods
+
+    class << self
+      def execute_post_request(path, params, headers)
+        params = Util.normalize_params(params)
+        headers[:authorization] = "Bearer #{Justifi::OAuth.get_token}"
+
+        headers = Util.normalize_headers(headers)
+        super(path, params, headers)
+      end
+
+      def execute_get_request(path, params, headers)
+        query = Util.encode_parameters(params)
+        headers[:authorization] = "Bearer #{Justifi::OAuth.get_token}"
+        headers = Util.normalize_headers(headers)
+
+        super(path, query, headers)
+      end
+
+      def execute_patch_request(path, params, headers)
+        params = Util.normalize_params(params)
+        headers[:authorization] = "Bearer #{Justifi::OAuth.get_token}"
+
+        headers = Util.normalize_headers(headers)
+        super(path, params, headers)
+      end
+
+      def list(path, params = {}, headers = {})
+        Justifi::ListObject.list(path, params, headers)
+      end
+    end
+  end
+end

data/lib/justifi/justifi_response.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Justifi
+  # Headers provides an access wrapper to an API response's header data. It
+  # mainly exists so that we don't need to expose the entire
+  # `Net::HTTPResponse` object while still getting some of its benefits like
+  # case-insensitive access to header names and flattening of header values.
+  class JustifiResponseHeaders
+    # Initializes a Headers object from a Net::HTTP::HTTPResponse object.
+    def self.from_net_http(resp)
+      new(resp.to_hash)
+    end
+
+    # `hash` is expected to be a hash mapping header names to arrays of
+    # header values. This is the default format generated by calling
+    # `#to_hash` on a `Net::HTTPResponse` object because headers can be
+    # repeated multiple times. Using `#[]` will collapse values down to just
+    # the first.
+    def initialize(hash)
+      if !hash.is_a?(Hash)
+        raise ArgumentError,
+          "expect hash to be a map of string header names to arrays of " \
+          "header values"
+      end
+
+      @hash = {}
+
+      # This shouldn't be strictly necessary because `Net::HTTPResponse` will
+      # produce a hash with all headers downcased, but do it anyway just in
+      # case an object of this class was constructed manually.
+      #
+      # Also has the effect of duplicating the hash, which is desirable for a
+      # little extra object safety.
+      hash.each do |k, v|
+        @hash[k.downcase] = v
+      end
+    end
+  end
+
+  module JustifiResponseBase
+    # A Hash of the HTTP headers of the response.
+    attr_accessor :http_headers
+
+    # The integer HTTP status code of the response.
+    attr_accessor :http_status
+
+    # The JustiFi request ID of the response.
+    attr_accessor :request_id
+
+    def self.populate_for_net_http(resp, http_resp)
+      resp.http_headers = JustifiResponseHeaders.from_net_http(http_resp)
+      resp.http_status = http_resp.code.to_i
+      resp.request_id = http_resp["request-id"]
+    end
+  end
+
+  # JustifiResponse encapsulates some vitals of a response that came back from
+  # the Justifi API.
+  class JustifiResponse
+    include JustifiResponseBase
+    # The data contained by the HTTP body of the response deserialized from
+    # JSON.
+    attr_accessor :data
+
+    # The raw HTTP body of the response.
+    attr_accessor :http_body
+
+    # The error error_message from JustiFi API
+    attr_accessor :error_message
+
+    # The boolean flag based on Net::HTTPSuccess
+    attr_accessor :success
+
+    # Initializes a JustifiResponse object from a Net::HTTP::HTTPResponse
+    # object.
+    def self.from_net_http(http_resp)
+      resp = JustifiResponse.new
+      resp.data = JSON.parse(http_resp.body, symbolize_names: true)
+      resp.http_body = http_resp.body
+      resp.success = http_resp.is_a? Net::HTTPSuccess
+      resp.error_message = resp.data.dig(:error, :message)
+      JustifiResponseBase.populate_for_net_http(resp, http_resp)
+      resp
+    end
+  end
+end

data/lib/justifi/list_object.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Justifi
+  class ListObject
+    extend Forwardable
+
+    attr_reader :justifi_object
+    attr_accessor :request_params, :request_headers, :path
+
+    def_delegators :@justifi_object, :data, :data
+    def_delegators :@justifi_object, :page_info, :page_info
+    def_delegators :@justifi_object, :http_status, :http_status
+    def_delegators :@justifi_object, :raw_response, :raw_response
+
+    # An empty list object to return when has_next or has_previous
+    # does not exist
+    def self.empty_list(headers = {})
+      JustifiObject.construct_from({data: []}, headers)
+    end
+
+    def initialize(justifi_object:, path:, params: {}, headers: {})
+      @justifi_object = justifi_object
+      @path = path
+      @request_params = params
+      @request_headers = headers
+    end
+
+    # Iterates through each resource in the page represented by the current
+    # `ListObject`.
+    def each(&block)
+      data.each(&block)
+    end
+
+    # Returns true if the page object contains no elements.
+    def empty?
+      data.empty?
+    end
+
+    def has_previous
+      page_info.has_previous
+    end
+
+    def has_next
+      page_info.has_next
+    end
+
+    def start_cursor
+      page_info.start_cursor
+    end
+
+    def end_cursor
+      page_info.end_cursor
+    end
+
+    # Fetches the next page based on page_info[:end_cursor] paginaton
+    def next_page(params = {}, headers = {})
+      return self.class.empty_list(headers) unless has_next
+
+      params[:after_cursor] = end_cursor
+
+      Justifi::ListObject.list(path, @request_params.merge(params), @request_headers.merge(headers))
+    end
+
+    # Fetches the next page based on page_info[:start_cursor] paginaton
+    def previous_page(params = {}, headers = {})
+      return self.class.empty_list(headers) unless has_previous
+
+      params[:before_cursor] = start_cursor
+
+      Justifi::ListObject.list(path, @request_params.merge(params), @request_headers.merge(headers))
+    end
+
+    def self.list(path, params = {}, headers = {})
+      justifi_object = JustifiOperations.execute_get_request(path, params, headers)
+      new(justifi_object: justifi_object, path: path, params: params, headers: headers)
+    end
+  end
+end

data/lib/justifi/oauth.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Justifi
+  module OAuth
+    module OAuthOperations
+      extend APIOperations::ClassMethods
+
+      def self.execute_post_request(path, params, headers)
+        params = Util.normalize_params(params.merge(Justifi.credentials))
+        super(path, params, headers)
+      end
+    end
+
+    class << self
+      def get_token(params = {}, headers = {})
+        token = Justifi.cache.get(:access_token)
+        return token unless token.nil?
+
+        response = OAuthOperations.execute_post_request(
+          "/oauth/token", params, headers
+        )
+
+        Justifi.cache.set_and_return(:access_token, response.access_token)
+      end
+    end
+  end
+end

data/lib/justifi/payment.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Justifi
+  module Payment
+    class << self
+      def create(params: {}, headers: {}, idempotency_key: nil, seller_account_id: nil)
+        headers[:seller_account] = seller_account_id if seller_account_id
+        JustifiOperations.idempotently_request("/v1/payments",
+          method: :post,
+          params: params,
+          headers: headers)
+      end
+
+      def create_refund(amount:, payment_id:, reason: nil, description: nil)
+        refund_params = {amount: amount, description: description, reason: reason}
+        JustifiOperations.idempotently_request("/v1/payments/#{payment_id}/refunds",
+          method: :post,
+          params: refund_params,
+          headers: {})
+      end
+
+      def list(params: {}, headers: {}, seller_account_id: nil)
+        headers[:seller_account] = seller_account_id if seller_account_id
+        JustifiOperations.execute_get_request("/v1/payments", params, headers)
+      end
+
+      def get(payment_id:, headers: {})
+        JustifiOperations.execute_get_request("/v1/payments/#{payment_id}",
+          {},
+          headers)
+      end
+
+      def update(payment_id:, params: {}, headers: {}, idempotency_key: nil)
+        JustifiOperations.idempotently_request("/v1/payments/#{payment_id}",
+          method: :patch,
+          params: params,
+          headers: {})
+      end
+
+      def capture(payment_id:, amount: nil, headers: {}, idempotency_key: nil)
+        params = amount.nil? ? {} : {amount: amount}
+        JustifiOperations.idempotently_request("/v1/payments/#{payment_id}/capture",
+          method: :post,
+          params: params,
+          headers: {})
+      end
+    end
+  end
+end