unit_ruby_sdk 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c537218faa351239ef177faffa0c2b9de8d40eebf52eb3608b55e76dc89746a
-  data.tar.gz: aee02b9bca0da9370d687d5e374e1210198f7224e4834e585d32998fb3a74582
+  metadata.gz: a46692704b238a1ee794e61279bd26e2362d46758df062c6798654e420d07c9b
+  data.tar.gz: 15d22512500136bbcab8a1a8cd6053fa87c6caa3faf1aec7d42d90b9bc8a5242
 SHA512:
-  metadata.gz: 30b0e0991cb6d0e291c0d6af7b4a8448ee293e06d06b1e7f2dac9b39b189807879eff0f048f788c41fc49045cd593dd319ee74e7c42fc7ec884c1495a3f45f8c
-  data.tar.gz: 0fbae70cf0069a97e19ab5bbf5284fe802f9355879e30f15484e63b13b67a56f5e141dfde7c2ed0f4b17298b4b618498e8f594239897c0e7ea3bc0b530981dbb
+  metadata.gz: d679b613f4d3d262f5a70523a1031a0fa7ab7ca07ce55530bd1bd2b8e8fe0f622f109e082db4df6b2ca0fb964e5ce0f96996975d21f7420c241ea436ed3d6589
+  data.tar.gz: 81bde72e0dc915f97f247edc4f96e41143a628d6f068d1e239edc27bdbd15b2f012ce78db3dbcd988fa28f223463bf8803191cf1a7379cb9026efe82b6546556

data/.rubocop.yml

@@ -30,5 +30,8 @@ Layout/LineLength:
 Style/ClassVars:
   Enabled: false
 
+Lint/UnderscorePrefixedVariableName:
+  Enabled: false
+
 Metrics/BlockLength:
   Enabled: false

data/Gemfile

@@ -4,13 +4,3 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in unit-ruby-sdk.gemspec
 gemspec
-
-gem "rake", "~> 13.0"
-
-gem "rubocop", "~> 1.21"
-
-gem "httparty", "~0.20.0"
-
-gem "ruby-debug-ide"
-
-gem "factory_bot_rails", "~> 6.2.0"

data/README.md

@@ -1 +1,73 @@
-# unit-ruby-sdk
+# unit_ruby_sdk
+
+This gem provides a ruby wrapper for [Unit's API](https://docs.unit.co/#introduction).
+
+## Documentation
+
+See [Unit's Docs](https://docs.unit.co)
+
+## Installation
+
+```bash
+gem install unit_ruby_sdk
+```
+
+## Usage
+
+### Creating a Business Application
+
+```ruby
+require 'unit_ruby_sdk'
+
+Unit.config(api_url: ENV['API_URL'], token: ENV['TOKEN'])
+
+full_name = Unit::Types::FullName.new('John', 'Doe')
+date_of_birth = '1980-08-10'
+address = Unit::Types::Address.new('123 Main St', 'San Francisco', 'CA', '94205', 'US')
+phone = Unit::Types::Phone.new('380', '555123222')
+email = 'jone.doe@unit-finance.com'
+ssn = '123456789'
+beneficial_owner = Unit::Types::BeneficialOwner.new(full_name, date_of_birth, address, phone, email, ssn)
+
+response = Unit::Application.create_business_application(
+  name: "Acme Inc.",
+  address: address,
+  phone: phone,
+  state_of_incorporation: "CA",
+  ein: '123456789',
+  industry: "Retail",
+  contact: Unit::Types::BusinessContact.new(full_name, email, phone),
+  officer: Unit::Types::Officer.new(full_name, date_of_birth, address, phone, email, ssn),
+  beneficial_owners: [beneficial_owner, beneficial_owner],
+  entity_type: 'LLC'
+)
+
+application = response.data
+
+puts application.id
+```
+
+### Fetching a Customer
+
+```ruby
+require 'unit_ruby_sdk'
+
+Unit.config(api_url: ENV['API_URL'], token: ENV['TOKEN'])
+
+customer = Unit::Customer.list_customers.first
+puts customer.id
+```
+
+### Logging Errors
+
+```ruby
+require 'unit_ruby_sdk'
+
+Unit.config(api_url: ENV['API_URL'], token: "missing token")
+
+# response is a Unit::UnitError
+response = Unit::Application.get_application('123')
+
+# Prints "Bearer token is missing"
+response.errors.each{|error| puts error.title}
+```

data/lib/unit/api_resources/account_resource.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "./base_resource"
+require_relative "../utils/http_helper"
+require "json"
+
+# class for creating request for accounts to Unit API and parsing responses
+# @see https://docs.unit.co/#accounts
+module Unit
+  module Resource
+    class AccountResource < Unit::Resource::BaseResource
+      class << self
+        # Create a new account by calling Unit's API
+        # @param request [CreateDepositAccountRequest] request
+        # @return [UnitResponse, UnitError]
+        def create_account(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/accounts", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Close an account by calling Unit's API
+        # @param request [CloseDepositAccountRequest] request
+        # @return [UnitResponse, UnitError]
+        def close_account(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/accounts/#{request.account_id}/close", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Reopen an account by calling Unit's API
+        # @param account_id [String]
+        # @param reason [String]
+        # @return [UnitResponse, UnitError]
+        def reopen_account(account_id)
+          response = HttpHelper.post("#{api_url}/accounts/#{account_id}/reopen", headers: headers)
+          response_handler(response)
+        end
+
+        # Freeze an account by calling Unit's API
+        # @param request [FreezeAccountRequest]
+        # @return [UnitResponse, UnitError]
+        def freeze_account(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/accounts/#{request.account_id}/freeze", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Unfreeze an account by calling Unit's API
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def unfreeze_account(account_id)
+          response = HttpHelper.post("#{api_url}/accounts/#{account_id}/unfreeze", headers: headers)
+          response_handler(response)
+        end
+
+        # Get account by calling Unit's API
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def get_account(account_id)
+          response = HttpHelper.get("#{api_url}/accounts/#{account_id}", headers: headers)
+          response_handler(response)
+        end
+
+        # List accounts by calling Unit's API
+        # @param params [ListAccountParams] - optional
+        # @return [UnitResponse, UnitError]
+        def list_accounts(params = nil)
+          response = HttpHelper.get("#{api_url}/accounts", params: params.to_hash, headers: headers)
+          response_handler(response)
+        end
+
+        # Update account by calling Unit's API
+        # @param request [PatchDepositAccountRequest]
+        def update_account(request)
+          payload = request.to_json_api
+          response = HttpHelper.patch("#{api_url}/accounts/#{request.account_id}", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Limit account by calling Unit's API
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def limits(account_id)
+          response = HttpHelper.get("#{api_url}/accounts/#{account_id}/limits", headers: headers)
+          response_handler(response)
+        end
+
+        # Get deposit products by calling Unit's API
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def get_deposit_products(account_id)
+          response = HttpHelper.get("#{api_url}/accounts/#{account_id}/deposit-products", headers: headers)
+          response_handler(response)
+        end
+
+        # Get account balance history by calling Unit's API
+        # @param params [BalanceHistoryRequest]
+        # @return [UnitResponse, UnitError]
+        def get_account_balance_history(params)
+          response = HttpHelper.get("#{api_url}/account-end-of-day", params: params.to_hash.to_json, headers: headers)
+          response_handler(response)
+        end
+
+        # Add account owners by calling Unit's API
+        # @param request [AccountOwnersRequest]
+        # @return [UnitResponse, UnitError]
+        def add_owners(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/accounts/#{request.account_id}/relationships/customers", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Remove account owners by calling Unit's API
+        # @param request [AccountOwnersRequest]
+        # @return [UnitResponse, UnitError]
+        def remove_owners(request)
+          payload = request.to_json_api
+          response = HttpHelper.delete("#{api_url}/accounts/#{request.account_id}/relationships/customers", body: payload, headers: headers)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end

data/lib/unit/api_resources/application_resource.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "httparty"
 require_relative "./base_resource"
+require_relative "../utils/http_helper"
 require "json"
 # class for creating requests for applications to Unit API and parsing responses
-# See: https://docs.unit.co/applications
+# @see https://docs.unit.co/applications
 module Unit
   module Resource
     class ApplicationResource < Unit::Resource::BaseResource
@@ -14,23 +14,23 @@ module Unit
         # @return [UnitResponse, UnitError]
         def create_application(request)
           payload = request.to_json_api
-          response = HTTParty.post("#{api_url}/applications", body: payload, headers: headers)
+          response = HttpHelper.post("#{api_url}/applications", body: payload, headers: headers)
           response_handler(response)
         end
 
         # Get an application by calling Unit's API
-        # @param [Integer] application_id
+        # @param [String] application_id
         # @return [UnitResponse, UnitError]
         def get_application(application_id)
-          response = HTTParty.get("#{api_url}/applications/#{application_id}", headers: headers)
+          response = HttpHelper.get("#{api_url}/applications/#{application_id}", headers: headers)
           response_handler(response)
         end
 
-        # Get an applications by calling Unit's API
+        # List applications by calling Unit's API
         # @param [ListApplicationParams] params
         # @return [UnitResponse, UnitError]
         def list_applications(params = nil)
-          response = HTTParty.get("#{api_url}/applications", body: params&.to_hash&.to_json, headers: headers)
+          response = HttpHelper.get("#{api_url}/applications", params: params&.to_hash, headers: headers)
           response_handler(response)
         end
 
@@ -50,7 +50,7 @@ module Unit
           headers["Content-Type"] = "image/jpeg" if request.file_type == "jpeg"
           headers["Content-Type"] = "image/png" if request.file_type == "png"
 
-          response = HTTParty.put(url, body: request.file, headers: headers)
+          response = HttpHelper.put(url, body: request.file, headers: headers)
 
           response_handler(response)
         end
@@ -60,7 +60,7 @@ module Unit
         # @return [UnitResponse, UnitError]
         def update(request)
           payload = request.to_json_api
-          response = HTTParty.patch("#{api_url}/applications/#{request.application_id}", body: payload, headers: headers)
+          response = HttpHelper.patch("#{api_url}/applications/#{request.application_id}", body: payload, headers: headers)
           response_handler(response)
         end
       end

data/lib/unit/api_resources/base_resource.rb

@@ -1,22 +1,14 @@
 # frozen_string_literal: true
 
-require "httparty"
-
 module Unit
   module Resource
     class BaseResource
       class << self
         # Check the response code and return a UnitResponse or UnitError
-        # @param [HTTParty::Response] response
+        # @param [HTTP::Response] response
         def response_handler(response)
-          included = response["included"].nil? ? nil : response["included"]
-          meta = response["meta"].nil? ? nil : response["meta"]
-          case response.code
-          when 200...300
-            Unit::UnitResponse.new(response["data"], included, meta)
-          else
-            Unit::UnitError.from_json_api(response)
-          end
+          handler = response.code.to_i.between?(200, 299) ? Unit::UnitResponse : Unit::UnitError
+          handler.from_json_api(response)
         end
 
         protected

data/lib/unit/api_resources/customer_resource.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require "httparty"
-
 require_relative "../api_resources/base_resource"
 require_relative "../models/unit_response"
 require_relative "../errors/unit_error"
+require_relative "../utils/http_helper"
 
 # class for creating requests for customers to Unit API and parsing responses
-# See: https://docs.unit.co/customers/
+# @see https://docs.unit.co/customers/
 module Unit
   module Resource
     class CustomerResource < Unit::Resource::BaseResource
@@ -17,7 +16,7 @@ module Unit
         # @return [UnitResponse, UnitError]
         def update(request)
           payload = request.to_json_api
-          response = HTTParty.patch("#{api_url}/customers/#{request.customer_id}", body: payload, headers: headers)
+          response = HttpHelper.patch("#{api_url}/customers/#{request.customer_id}", body: payload, headers: headers)
           response_handler(response)
         end
 
@@ -25,7 +24,7 @@ module Unit
         # @param [String] customer_id
         # @return [UnitResponse, UnitError]
         def get(customer_id)
-          response = HTTParty.get("#{api_url}/customers/#{customer_id}", headers: headers)
+          response = HttpHelper.get("#{api_url}/customers/#{customer_id}", headers: headers)
           response_handler(response)
         end
 
@@ -33,7 +32,7 @@ module Unit
         # @param [ListCustomerParams] params
         # @return [UnitResponse, UnitError]
         def list(params = nil)
-          response = HTTParty.get("#{api_url}/customers", body: params&.to_hash&.to_json, headers: headers)
+          response = HttpHelper.get("#{api_url}/customers", params: params&.to_hash, headers: headers)
           response_handler(response)
         end
 
@@ -42,7 +41,7 @@ module Unit
         # @return [UnitResponse, UnitError]
         def archive(request)
           payload = request.to_json_api
-          response = HTTParty.post("#{api_url}/customers/#{request.customer_id}/archive", body: payload, headers: headers)
+          response = HttpHelper.post("#{api_url}/customers/#{request.customer_id}/archive", body: payload, headers: headers)
           response_handler(response)
         end
 
@@ -51,9 +50,11 @@ module Unit
         # @return [UnitResponse, UnitError]
         def add_authorized_users(request)
           payload = request.to_json_api
-          response = HTTParty.post("#{api_url}/customers/#{request.customer_id}/authorized-users",
-                                   body: payload,
-                                   headers: headers)
+          response = HttpHelper.post(
+            "#{api_url}/customers/#{request.customer_id}/authorized-users",
+            body: payload,
+            headers: headers
+          )
           response_handler(response)
         end
 
@@ -62,7 +63,7 @@ module Unit
         # @return [UnitResponse, UnitError]
         def remove_authorized_users(request)
           payload = request.to_json_api
-          response = HTTParty.delete("#{api_url}/customers/#{request.customer_id}/authorized-users", body: payload, headers: headers)
+          response = HttpHelper.delete("#{api_url}/customers/#{request.customer_id}/authorized-users", body: payload, headers: headers)
           response_handler(response)
         end
       end

data/lib/unit/errors/unit_error.rb

@@ -5,25 +5,19 @@ require_relative "unit_error_payload"
 # Represents an Error returned from Unit's API
 module Unit
   class UnitError
+    attr_reader :errors
+
     # Create a new UnitError
     # @param [Array<UnitErrorPayload>] errors
     def initialize(errors)
       @errors = errors
     end
 
-    class << self
-      # Creates a new UnitError from given response.
-      # @param [Hash] response The response returned from Unit's API
-      # @return [UnitError] a new UnitError populated with values taken from the response
-      def from_json_api(response)
-        errors = response["errors"]
-
-        errors&.map do |error|
-          UnitErrorPayload.new(error["title"], error["status"],
-                               error["detail"], error["details"], error["source"], error["code"])
-        end
-        UnitError.new(errors)
-      end
+    # Creates a new UnitError from given response.
+    # @param [HTTP::Response] response The response returned from Unit's API
+    # @return [UnitError] a new UnitError populated with values taken from the response
+    def self.from_json_api(response)
+      new((response.body["errors"] || []).map { |error| UnitErrorPayload.from_json_api(error) })
     end
   end
 end

data/lib/unit/errors/unit_error_payload.rb

@@ -11,8 +11,7 @@ module Unit
     # @param source [Hash] The source of the error
     # @param code [String] A Unit-specific code, uniquely identifying the error type
     # Check out documentation link for more details: https://docs.unit.co/about-jsonapi/#intro-errors
-    def initialize(title, status, detail, details = nil,
-                   source = nil, code = nil)
+    def initialize(title, status, detail, details = nil, source = nil, code = nil)
       @title = title
       @status = status
       @detail = detail
@@ -20,5 +19,19 @@ module Unit
       @source = source
       @code = code
     end
+
+    # Creates a new UnitErrorPayload from given response error.
+    # @param [Hash] error One of the errors returned in a response from Unit's API
+    # @return [UnitErrorPayload] a new UnitErrorPayload populated with values taken from the response error
+    def self.from_json_api(error)
+      new(
+        error["title"],
+        error["status"],
+        error["detail"],
+        error["details"],
+        error["source"],
+        error["code"]
+      )
+    end
   end
 end

data/lib/unit/models/account/account.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Unit
+  module Account
+    module Deposit
+      ACCOUNT_LIST_LIMIT = 100
+      ACCOUNT_LIST_OFFSET = 0
+      BALANCE_HISTORY_LIMIT = 100
+      BALANCE_HISTORY_OFFSET = 0
+      autoload :CreateDepositAccountRequest, "unit/models/account/deposit/create_deposit_account_request"
+      autoload :CloseDepositAccountRequest, "unit/models/account/deposit/close_deposit_account_request"
+      autoload :AccountOwnersRequest, "unit/models/account/deposit/account_owners_request"
+      autoload :BalanceHistoryRequest, "unit/models/account/deposit/balance_history_request"
+      autoload :FreezeAccountRequest, "unit/models/account/deposit/freeze_account_request"
+      autoload :ListAccountParams, "unit/models/account/deposit/list_account_params"
+      autoload :PatchDepositAccountRequest, "unit/models/account/deposit/patch_deposit_account_request"
+
+      class << self
+        # Create a deposit account
+        # @see https://docs.unit.co/deposit-accounts#create-deposit-account
+        # @param deposit_product [String]
+        # @param tags [Hash]- optional
+        # @param idempotency_key [String] - optional
+        # @param relationships [Relationships, RelationshipArray] - optional
+        # @return [UnitResponse, UnitError]
+        def create_deposit_account(deposit_product:, tags: nil, relationships: nil, idempotency_key: nil)
+          request = CreateDepositAccountRequest.new(deposit_product, tags, relationships, idempotency_key)
+          Unit::Resource::AccountResource.create_account(request)
+        end
+
+        # Close deposit account
+        # @see https://docs.unit.co/deposit-accounts#close-account
+        # @param account_id [String]
+        # @param reason [String]
+        # @param fraud_reason [String] - optional
+        # @return [UnitResponse, UnitError]
+        def close_deposit_account(account_id:, reason:)
+          request = CloseDepositAccountRequest.new(account_id, reason)
+          Unit::Resource::AccountResource.close_account(request)
+        end
+
+        # Reopen deposit account
+        # @see https://docs.unit.co/deposit-accounts#reopen-account
+        # @param account_id [String]
+        # @param reason [String]
+        def reopen_account(account_id:)
+          Unit::Resource::AccountResource.reopen_account(account_id)
+        end
+
+        # Get a deposit account by id
+        # @see https://docs.unit.co/deposit-accounts#get-specific-deposit-account
+        # @param account_id [String]
+        def get_deposit_account(account_id:)
+          Unit::Resource::AccountResource.get_account(account_id)
+        end
+
+        # Freeze deposit account
+        # @see https://docs.unit.co/deposit-accounts#freeze-account
+        # @param account_id [String]
+        # @param reason [String]
+        # @param reason_text [String] - optional
+        # @return [UnitResponse, UnitError]
+        def freeze_account(account_id:, reason:, reason_text: nil)
+          request = FreezeAccountRequest.new(account_id, reason, reason_text)
+          Unit::Resource::AccountResource.freeze_account(request)
+        end
+
+        # Unfreeze deposit account
+        # @see https://docs.unit.co/deposit-accounts#freeze-account
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def unfreeze_account(account_id:)
+          Unit::Resource::AccountResource.unfreeze_account(account_id)
+        end
+
+        # Listing deposit accounts
+        # @see https://docs.unit.co/deposit-accounts#list-deposit-accounts
+        # @param limit [Integer] - optional
+        # @param offset [Integer] - optional
+        # @param customer_id [String] - optional
+        # @param tags [Hash] - optional
+        # @param status [String] - optional
+        # @param from_balance [Integer] - optional
+        # @param to_balance [Integer] - optional
+        # @param include [String] - optional
+        # @return [UnitResponse, UnitError]
+        def list_deposit_accounts(limit: ACCOUNT_LIST_LIMIT, offset: ACCOUNT_LIST_OFFSET, customer_id: nil, tags: nil,
+                                  status: nil, from_balance: nil, to_balance: nil, include: nil)
+          request = ListAccountParams.new(limit, offset, customer_id, tags, status, from_balance, to_balance, include)
+          Unit::Resource::AccountResource.list_accounts(request)
+        end
+
+        # Update a deposit account
+        # @see https://docs.unit.co/deposit-accounts#update-accounts
+        # @param account_id [String]
+        # @param tags [Hash] - optional
+        # @param deposit_product [String] - optional
+        # @return [UnitResponse, UnitError]
+        def update_deposit_account(account_id:, tags: nil, deposit_product: nil)
+          request = PatchDepositAccountRequest.new(account_id, tags, deposit_product)
+          Unit::Resource::AccountResource.update_account(request)
+        end
+
+        # Limit a deposit account
+        # @see https://docs.unit.co/deposit-accounts#account-limits
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def limits(account_id:)
+          Unit::Resource::AccountResource.limits(account_id)
+        end
+
+        # Get deposit products
+        # @see https://docs.unit.co/deposit-accounts#account-deposit-products
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def get_deposit_products(account_id:)
+          Unit::Resource::AccountResource.get_deposit_products(account_id)
+        end
+
+        # Get account balance history by calling Unit's API
+        # @see https://docs.unit.co/deposit-accounts#get-account-balance-history
+        # @param limit [Integer] - optional
+        # @param offset [Integer] - optional
+        # @param account_id [String] - optional
+        # @param customer_id [String] - optional
+        # @param since [String] - optional
+        # @param _until [String] - optional
+        # @return [UnitResponse, UnitError]
+        def get_balance_history(limit = BALANCE_HISTORY_LIMIT, offset = BALANCE_HISTORY_OFFSET, account_id: nil, customer_id: nil,
+                                since: nil, _until: nil)
+          request = BalanceHistoryRequest.new(limit, offset, account_id, customer_id, since, _until)
+          Unit::Resource::AccountResource.get_account_balance_history(request)
+        end
+
+        # Add account owners by calling Unit's API
+        # @see https://docs.unit.co/deposit-accounts#account-add-owners
+        # @param account_id [String]
+        # @param customers [Array<String>]
+        # @return [UnitResponse, UnitError]
+        def add_owners(account_id:, customers:)
+          request = AccountOwnersRequest.new(account_id, customers)
+          Unit::Resource::AccountResource.add_owners(request)
+        end
+
+        # Remove account owners by calling Unit's API
+        # @see https://docs.unit.co/deposit-accounts#account-remove-owners
+        # @param account_id [String]
+        # @param customers [Array<Customer>]
+        # @return [UnitResponse, UnitError]
+        def remove_owners(account_id:, customers:)
+          request = AccountOwnersRequest.new(account_id, customers)
+          Unit::Resource::AccountResource.remove_owners(request)
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/account/deposit/account_owners_request.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Request to add or remove owners to a deposit account
+# @see https://docs.unit.co/deposit-accounts#account-add-owners
+# @see https://docs.unit.co/deposit-accounts#account-remove-owners
+module Unit
+  module Account
+    module Deposit
+      class AccountOwnersRequest
+        attr_reader :account_id, :customers
+
+        # @param account_id [String]
+        # @param customers [Array<String>]
+        def initialize(account_id, customers)
+          @account_id = account_id
+          @customers = customers
+        end
+
+        def to_json_api
+          customers_hash = customers.map do |customer|
+            { "type": "customer", "id": customer }
+          end
+          result = { data: customers_hash }
+          result.to_json
+        end
+      end
+    end
+  end
+end