unit-ruby 0.1.0

data/lib/unit-ruby/types/array.rb

@@ -0,0 +1,21 @@
+module Unit
+  module Types
+    class Array
+      attr_reader :items
+
+      def initialize(items)
+        @items = items || []
+      end
+
+      def self.cast(val)
+        return val if val.is_a? self
+
+        new(val)
+      end
+
+      def as_json_api
+        items
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/boolean.rb

@@ -0,0 +1,16 @@
+module Unit
+  module Types
+    class Boolean
+      def self.cast(value)
+        return nil if value.nil?
+
+        case value
+        when 'false', '0', 0, false
+          false
+        when 'true', '1', 1, true
+          true
+        end
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/coordinates.rb

@@ -0,0 +1,23 @@
+module Unit
+  module Types
+    class Coordinates
+      attr_reader :longitude, :latitude
+
+      def initialize(longitude:, latitude:)
+        @longitude = longitude
+        @latitude = latitude
+      end
+
+      def self.cast(val)
+        return val if val.is_a? self
+        return nil if val.nil?
+
+        new(longitude: val[:longitude], latitude: val[:latitude])
+      end
+
+      def as_json_api
+        { longitude: longitude, latitude: latitude }
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/date.rb

@@ -0,0 +1,11 @@
+module Unit
+  module Types
+    class Date
+      def self.cast(value)
+        return nil if value.nil?
+
+        ::Date.parse(value).strftime('%F')
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/date_time.rb

@@ -0,0 +1,11 @@
+module Unit
+  module Types
+    class DateTime
+      def self.cast(value)
+        return nil if value.nil?
+
+        ::Date.parse(value).iso8601
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/decimal.rb

@@ -0,0 +1,9 @@
+module Unit
+  module Types
+    class Decimal
+      def self.cast(value)
+        value&.to_d
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/float.rb

@@ -0,0 +1,9 @@
+module Unit
+  module Types
+    class Float
+      def self.cast(value)
+        value&.to_f
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/full_name.rb

@@ -0,0 +1,23 @@
+module Unit
+  module Types
+    class FullName
+      attr_reader :first, :last
+
+      def initialize(first:, last:)
+        @first = first
+        @last = last
+      end
+
+      def self.cast(val)
+        return val if val.is_a? self
+        return nil if val.nil?
+
+        new(first: val[:first], last: val[:last])
+      end
+
+      def as_json_api
+        { first: first, last: last }
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/hash.rb

@@ -0,0 +1,21 @@
+module Unit
+  module Types
+    class Hash
+      attr_reader :items
+
+      def initialize(items)
+        @items = items || {}
+      end
+
+      def self.cast(val)
+        return val if val.is_a? self
+
+        new(val)
+      end
+
+      def as_json_api
+        items
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/integer.rb

@@ -0,0 +1,9 @@
+module Unit
+  module Types
+    class Integer
+      def self.cast(value)
+        value&.to_i
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/phone.rb

@@ -0,0 +1,23 @@
+module Unit
+  module Types
+    class Phone
+      attr_reader :country_code, :number
+
+      def initialize(country_code:, number:)
+        @country_code = country_code
+        @number = number
+      end
+
+      def self.cast(val)
+        return val if val.is_a? self
+        return nil if val.nil?
+
+        new(country_code: val[:country_code], number: val[:number])
+      end
+
+      def as_json_api
+        { country_code: country_code, number: number }
+      end
+    end
+  end
+end

data/lib/unit-ruby/types/string.rb

@@ -0,0 +1,9 @@
+module Unit
+  module Types
+    class String
+      def self.cast(value)
+        value&.to_s
+      end
+    end
+  end
+end

data/lib/unit-ruby/util/api_resource.rb

@@ -0,0 +1,179 @@
+module Unit
+  module Util
+    class APIResource
+      attr_accessor :id, :type
+
+      def initialize(attributes = {})
+        clear_attributes!
+        mark_as_clean!
+
+        attributes.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      # Creates a base http connection to the API
+      #
+      def self.connection
+        @connection ||= Connection.new
+      end
+
+      # Defines the schema for a resource's attributes
+      #
+      def self.schema
+        @schema ||= Util::Schema.new
+      end
+
+      def schema
+        self.class.schema
+      end
+
+      # Declares a new attribute by name and adds it to the schema
+      #
+      # @param name [Symbol] the name of the attribute
+      # @param type [Class] the object type
+      # @param readonly [Boolean] excludes the attribute from the request when creating a resource
+      def self.attribute(name, type = nil, readonly: false)
+        schema.add(name, type, readonly: readonly)
+
+        attr_accessor name
+
+        define_method("#{name}=") do |value|
+          previous_value = send(name)
+          new_value = type.cast(value)
+
+          instance_variable_set("@#{name}", new_value)
+
+          mark_attribute_as_dirty(name) if new_value != previous_value
+          new_value
+        end
+      end
+
+      def relationships
+        @relationships ||= {}
+      end
+
+      attr_writer :relationships
+
+      # Sets the base path for this resource
+      #
+      # Usage:
+      #  class Customer < Unit::Resource
+      #      path '/customers'
+      #  end
+      def self.path(route = nil)
+        return @path if route.nil?
+
+        @path = route
+      end
+
+      def self.resource_path(id)
+        "#{path}/#{id}"
+      end
+
+      def self.resources_path
+        path
+      end
+
+      # The JSON:API type for this resource
+      def resource_type
+        self.class.name.split('::').last.camelize(:lower)
+      end
+
+      def resource_path
+        "#{self.class.path}/#{id}"
+      end
+
+      # Creates an association to a related resource
+      # This will create a helper method to traverse into a resource's related resource(s)
+      def self.belongs_to(resource_name, class_name: nil)
+        class_name ||= resource_name.to_s.camelize
+
+        define_method(resource_name) do
+          relationship_id = relationships[resource_name][:data]&.fetch(:id)
+
+          return nil unless relationship_id
+
+          Kernel.const_get(class_name).find(relationship_id)
+        end
+
+        define_method("#{resource_name}=") do |resource|
+          relationships[resource_name] = {
+            data: { type: resource_name, id: resource.id }
+          }
+        end
+      end
+
+      # Hyrdates an instance of the resource from data returned from the API
+      def self.build_resource_from_json_api(data_item)
+        new.tap do |resource|
+          resource.mark_as_clean!
+          resource.update_resource_from_json_api(data_item)
+        end
+      end
+
+      def update_resource_from_json_api(data)
+        self.id = data[:id]
+        self.type = data[:type]
+        self.relationships = data[:relationships]
+
+        clear_attributes!
+
+        data[:attributes].each { |key, value| update_attribute(key, value) }
+
+        mark_as_clean!
+      end
+
+      # Represents this resource's attributes
+      #
+      # @return [Hash] Representation of this resource's attributes as a hash
+      def attributes
+        self.class.schema.attributes.each_with_object({}) do |schema_attribute, h|
+          h[schema_attribute.name] = send(schema_attribute.name)
+        end
+      end
+
+      # Represents this resource for serialization (create/update)
+      #
+      # @return [Hash] Representation of this object as JSONAPI object
+      def as_json_api
+        self.class.schema.attributes.each_with_object({}) do |schema_attribute, h|
+          next if schema_attribute.readonly
+
+          val = send(schema_attribute.name)
+
+          # serialize the value if it is a complex type
+          val = val.as_json_api if val.respond_to? :as_json_api
+
+          h[schema_attribute.name] = val
+        end
+      end
+
+      def dirty?
+        dirty_attributes.any?
+      end
+
+      def dirty_attributes
+        @dirty_attributes ||= []
+      end
+
+      def mark_attribute_as_dirty(name)
+        dirty_attributes << name
+      end
+
+      def mark_as_clean!
+        @dirty_attributes = []
+      end
+
+      def clear_attributes!
+        self.class.schema.attributes.each do |attribute|
+          update_attribute(attribute.name, nil)
+        end
+      end
+
+      def update_attribute(name, value)
+        send("#{name}=", value)
+      end
+    end
+  end
+end

data/lib/unit-ruby/util/connection.rb

@@ -0,0 +1,72 @@
+module Unit
+  module Util
+    class Connection
+      class << self
+        attr_accessor :api_key, :base_url
+      end
+
+      attr_reader :connection
+
+      def initialize
+        @connection = Faraday.new(self.class.base_url) do |f|
+          f.headers['Authorization'] = "Bearer #{self.class.api_key}"
+          f.request :json # encode req bodies as JSON
+          f.request :retry # retry transient failures
+          f.response :follow_redirects # follow redirects
+          f.response :json # decode response bodies as JSON
+        end
+      end
+
+      # Executes a GET request to the API
+      #
+      # @return the resource (or array of resources) returned from the API
+      def get(path, params = nil)
+        response = connection.get(path, params)
+
+        handle_errors(response)
+
+        from_json_api(response.body)
+      end
+
+      # Executes a POST request to the API
+      #
+      # @return [Unit::APIResource] a new instance of the resource
+      def post(path, data = nil)
+        response = connection.post do |req|
+          req.url path
+          req.headers['Content-Type'] = 'application/vnd.api+json'
+          req.body = data.deep_transform_keys! { |key| key.to_s.camelize(:lower) } if data
+        end
+
+        handle_errors(response)
+
+        from_json_api(response.body)
+      end
+
+      # Executes a PATCH request to the API
+      def patch(path, data = nil)
+        response = connection.patch do |req|
+          req.url path
+          req.headers['Content-Type'] = 'application/vnd.api+json'
+          req.body = data.deep_transform_keys! { |key| key.to_s.camelize(:lower) } if data
+        end
+
+        handle_errors(response)
+
+        from_json_api(response.body)
+      end
+
+      def from_json_api(response_body)
+        response_body.deep_transform_keys do |key|
+          key.to_s.underscore.to_sym
+        end.fetch(:data)
+      end
+
+      def handle_errors(response)
+        return if response.success?
+
+        raise(Error, response.body)
+      end
+    end
+  end
+end

data/lib/unit-ruby/util/error.rb

@@ -0,0 +1,16 @@
+module Unit
+  module Util
+    class Error < StandardError
+      attr_accessor :title, :status, :details, :detail
+
+      def initialize(api_response)
+        error = api_response['errors'].first
+        @title = error['title']
+        @status = error['status']
+        @details = error['details'] || error['detail']
+
+        super(@details)
+      end
+    end
+  end
+end

data/lib/unit-ruby/util/resource_operations.rb

@@ -0,0 +1,82 @@
+module Unit
+  module Util
+    module ResourceOperations
+      module Find
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def find(id)
+            located_resource = connection.get(resource_path(id))
+
+            build_resource_from_json_api(located_resource)
+          end
+        end
+      end
+
+      module Create
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def create(attributes)
+            resource = new(attributes)
+
+            data = {
+              type: resource.resource_type,
+              attributes: resource.as_json_api.slice(*resource.dirty_attributes)
+            }
+            unless resource.relationships.empty?
+              data[:relationships] =
+                resource.relationships
+            end
+
+            created_resource = connection.post(resources_path, { data: data })
+
+            build_resource_from_json_api(created_resource)
+          end
+        end
+      end
+
+      module List
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          # List resources
+          #
+          # @param where [Hash] Optional. Filters to apply to the list.
+          # @param limit	[Integer] Optional. Maximum number of resources that will be returned. Maximum is 1000 resources.
+          # @param offset	[Integer] Optional. Number of resources to skip
+          # @param sort [String] Optional. sort: 'createdAt' for ascending order or sort: '-createdAt' (leading minus sign) for descending order
+          def list(where: {}, limit: 100, offset: 0, sort: nil)
+            params = { filter: where, page: { offset: offset, limit: limit },
+                       sort: sort }.compact
+            resources = connection.get(resources_path, params)
+
+            resources.map { |resource| build_resource_from_json_api(resource) }
+          end
+        end
+      end
+
+      module Save
+        def save
+          updated_resource = self.class.connection.patch(
+            resource_path,
+            {
+              data: {
+                type: resource_type,
+                attributes: as_json_api.slice(*dirty_attributes)
+              }
+            }
+          )
+
+          update_resource_from_json_api(updated_resource)
+        end
+      end
+    end
+  end
+end

data/lib/unit-ruby/util/schema.rb

@@ -0,0 +1,16 @@
+module Unit
+  module Util
+    class Schema
+      Attribute = Struct.new(:name, :type, :readonly)
+
+      def initialize
+        @attributes = []
+      end
+
+      def add(name, type, readonly: false)
+        @attributes << Attribute.new(name, type, readonly)
+      end
+      attr_reader :attributes
+    end
+  end
+end

data/lib/unit-ruby/version.rb

@@ -0,0 +1,3 @@
+module Unit
+  VERSION = '0.1.0'
+end

data/lib/unit-ruby.rb

@@ -0,0 +1,41 @@
+require 'unit-ruby/util/connection'
+require 'unit-ruby/util/error'
+require 'unit-ruby/util/api_resource'
+require 'unit-ruby/util/resource_operations'
+require 'unit-ruby/util/schema'
+
+require 'unit-ruby/types/address'
+require 'unit-ruby/types/application_form_prefill'
+require 'unit-ruby/types/application_form_settings_override'
+require 'unit-ruby/types/array'
+require 'unit-ruby/types/boolean'
+require 'unit-ruby/types/coordinates'
+require 'unit-ruby/types/date_time'
+require 'unit-ruby/types/date'
+require 'unit-ruby/types/decimal'
+require 'unit-ruby/types/float'
+require 'unit-ruby/types/full_name'
+require 'unit-ruby/types/hash'
+require 'unit-ruby/types/integer'
+require 'unit-ruby/types/phone'
+require 'unit-ruby/types/string'
+
+require 'unit-ruby/application_form'
+require 'unit-ruby/atm_location'
+require 'unit-ruby/deposit_account'
+require 'unit-ruby/individual_application'
+require 'unit-ruby/individual_customer'
+require 'unit-ruby/individual_debit_card'
+require 'unit-ruby/institution'
+require 'unit-ruby/version'
+
+module Unit
+  # Usage:
+  #   Unit.configure do |config|
+  #     config.api_key = '<your api key>'
+  #     config.base_url = 'https://api.s.unit.sh'
+  #   end
+  def self.configure
+    yield(Util::Connection)
+  end
+end

data/unit-ruby.gemspec

@@ -0,0 +1,44 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'unit-ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'unit-ruby'
+  spec.version       = Unit::VERSION
+  spec.authors       = ['Chloe Isacke']
+  spec.email         = ['chloe@retirable.com']
+
+  spec.summary       = 'A Ruby gem for communicating with the Unit API.'
+  spec.homepage      = 'https://github.com/retirable/unit-ruby'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org/'
+
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/retirable/unit-ruby'
+    spec.metadata['changelog_uri'] = 'https://github.com/retirable/unit-ruby/blob/main/CHANGELOG.md'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+          'public gem pushes.'
+  end
+
+  # 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{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'faraday', '~> 1.8.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.24.1'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end