plaid 3.0.0 → 4.0.0

data/Rakefile

@@ -9,8 +9,7 @@ RDoc::Task.new do |rdoc|
   rdoc.generator = 'sdoc'
   rdoc.main = 'README.md'
 
-  rdoc.rdoc_files.include('README.md', 'LICENSE', 'UPGRADING.md',
-                          'CONTRIBUTING.md', 'CHANGELOG.md', 'lib/**/*.rb')
+  rdoc.rdoc_files.include('README.md', 'LICENSE', 'UPGRADING.md', 'lib/**/*.rb')
   rdoc.markup = 'tomdoc'
 end
 

data/bin/console

@@ -2,12 +2,13 @@
 
 require 'bundler/setup'
 require 'plaid'
-require 'pry'
 
-Plaid.config do |p|
-  p.env = :tartan
-  p.client_id = ENV['PLAID_CLIENT_ID']
-  p.secret = ENV['PLAID_SECRET']
-end
+# 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.
 
-Pry.start
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: 2.2.2

data/lib/plaid.rb

@@ -1,64 +1,19 @@
-require 'plaid/version'
-require 'plaid/errors'
-require 'plaid/connector'
-require 'plaid/category'
-require 'plaid/institution'
-require 'plaid/user'
-require 'plaid/transaction'
-require 'plaid/info'
-require 'plaid/income'
-require 'plaid/client'
-require 'plaid/webhook'
-
-require 'uri'
+require_relative 'plaid/client'
+require_relative 'plaid/connect'
+require_relative 'plaid/errors'
+require_relative 'plaid/version'
+require_relative 'plaid/products/accounts'
+require_relative 'plaid/products/auth'
+require_relative 'plaid/products/categories'
+require_relative 'plaid/products/credit_details'
+require_relative 'plaid/products/identity'
+require_relative 'plaid/products/income'
+require_relative 'plaid/products/institutions'
+require_relative 'plaid/products/item'
+require_relative 'plaid/products/processor'
+require_relative 'plaid/products/sandbox'
+require_relative 'plaid/products/transactions'
 
 # Public: The Plaid namespace.
 module Plaid
-  # Public: Available Plaid products.
-  PRODUCTS = %i(connect auth info income risk).freeze
-
-  class <<self
-    # Public: The default Client.
-    attr_accessor :client
-
-    # Public: The Integer read timeout for requests to Plaid HTTP API.
-    # Should be specified in seconds. Default value is 120 (2 minutes).
-    attr_accessor :read_timeout
-
-    # Public: A helper function to ease configuration.
-    #
-    # Yields self.
-    #
-    # Examples
-    #
-    #   Plaid.configure do |p|
-    #     p.client_id = 'Plaid provided client ID here'
-    #     p.secret = 'Plaid provided secret key here'
-    #     p.env = :tartan
-    #     p.read_timeout = 300   # it's 5 minutes, yay!
-    #   end
-    #
-    # Returns nothing.
-    def config
-      client = Client.new
-      yield client
-      self.client = client
-    end
-
-    # Internal: Symbolize keys (and values) for a hash.
-    #
-    # hash   - The Hash with string keys (or nil).
-    # values - The Boolean flag telling the function to symbolize values
-    #          as well.
-    #
-    # Returns a Hash with keys.to_sym (or nil if hash is nil).
-    def symbolize_hash(hash, values: false)
-      return unless hash
-      return hash.map { |h| symbolize_hash(h) } if hash.is_a?(Array)
-
-      hash.each_with_object({}) do |(k, v), memo|
-        memo[k.to_sym] = values ? v.to_sym : v
-      end
-    end
-  end
 end

data/lib/plaid/client.rb

@@ -1,69 +1,137 @@
+# Public: The Plaid namespace.
 module Plaid
-  # Public: A class encapsulating client_id, secret, and Plaid API URL.
+  # Internal: Map environment to Plaid environment URL
+  #
+  # env - The type of the environment in symbol form
+  #
+  # Returns a string representing an environment URL
+  def self.url_from_env(env)
+    case env
+    when :sandbox
+      'https://sandbox.plaid.com/'
+    when :development
+      'https://development.plaid.com/'
+    when :production
+      'https://production.plaid.com/'
+    end
+  end
+
+  # Public: A class encapsulating client_id, secret, public key, and Plaid environment.
   class Client
-    # Public: The String Plaid account client ID to authenticate requests.
-    attr_accessor :client_id
+    # Internal: Set Plaid environment to use
+    #
+    # Handles converting an env symbol into an environment URL
+    #
+    # env - The Symbol (:sandbox, :development, :production)
+    #
+    # Returns a string representing the environment URL or raises an error
+    def env_map(env)
+      (@env = Plaid.url_from_env(env)) || raise(ArgumentError, 'Invalid value for ' \
+                                                                'Plaid::Client.env ' \
+                                                                "(#{env.inspect}): " \
+                                                                'must be :sandbox, '\
+                                                                ':development, or :production ')
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Account
+    def accounts
+      @accounts ||= Plaid::Accounts.new(self)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Auth
+    def auth
+      @auth ||= Plaid::Auth.new(self)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Categories
+    def categories
+      @categories ||= Plaid::Categories.new(self)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::CreditDetails
+    def credit_details
+      @credit_details ||= Plaid::CreditDetails.new(self)
+    end
 
-    # Public: The String Plaid account secret to authenticate requests.
-    attr_accessor :secret
+    # Public: Memoized class instance to make requests from Plaid::Identity
+    def identity
+      @identity ||= Plaid::Identity.new(self)
+    end
 
-    # Public: Plaid environment, i.e. String base URL of the API site.
+    # Public: Memoized class instance to make requests from Plaid::Income
+    def income
+      @income ||= Plaid::Income.new(self)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Institutions
+    def institutions
+      @institutions ||= Plaid::Institutions.new(self)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Item
+    def item
+      @item ||= Plaid::Item.new(self)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Processor
+    def processor
+      @processor ||= Plaid::Processor.new(self)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Sandbox
+    def sandbox
+      @sandbox ||= Plaid::Sandbox.new(self)
+    end
+
+    # Public: Memoized class instance to make requests from Plaid::Transactions
+    def transactions
+      @transactions ||= Plaid::Transactions.new(self)
+    end
+
+    # Public: Construct a Client instance
     #
-    # E.g. 'https://tartan.plaid.com'.
-    attr_reader :env
+    # env        - The Symbol (:sandbox, :development, :production)
+    # client_id  - The String Plaid account client ID to authenticate requests
+    # secret     - The String Plaid account secret to authenticate requests
+    # public_key - The String Plaid account public key to authenticate requests
+    def initialize(env:, client_id:, secret:, public_key:)
+      @env        = env_map(env)
+      @client_id  = client_id
+      @secret     = secret
+      @public_key = public_key
+    end
 
-    # Public: Set Plaid environment to use.
+    # Public: Make a post request
     #
-    # env - The Symbol (:tartan, :production), or a full String URL like
-    #       'https://tartan.plaid.com'.
-    def env=(env)
-      case env
-      when :tartan
-        @env = 'https://tartan.plaid.com/'
-      when :production
-        @env = 'https://api.plaid.com/'
-      when String
-        begin
-          URI.parse(env)
-          @env = env
-        rescue
-          raise ArgumentError, 'Invalid URL in Plaid::Client.env' \
-                               " (#{env.inspect}). " \
-                               'Specify either Symbol (:tartan, :production),' \
-                               " or a full URL, like 'https://tartan.plaid.com'"
-        end
-      else
-        raise ArgumentError, 'Invalid value for Plaid::Client.env' \
-                             " (#{env.inspect}): " \
-                             'must be :tartan, :production, or a full URL, ' \
-                             "e.g. 'https://tartan.plaid.com'"
-      end
-    end
-
-    # Public: Construct a Client instance.
+    # path    - Path or URL to make the request to
+    # payload - The payload or data to post
     #
-    # env       - The Symbol (:tartan, :production), or a full String URL like
-    #             'https://tartan.plaid.com'.
-    # client_id - The String Plaid account client ID to authenticate requests.
-    # secret    - The String Plaid account secret to authenticate requests.
-    def initialize(env: nil, client_id: nil, secret: nil)
-      env && self.env = env
-      self.client_id = client_id
-      self.secret = secret
+    # Returns the resulting parsed JSON of the request
+    def post(path, payload)
+      Plaid::Connect.post(File.join(@env, path), payload)
     end
 
-    # Public: Check if client_id is configured.
+    # Public: Make a post request with appended authentication fields
+    #
+    # path    - Path or URL to make the request to
+    # payload - The payload or data to post
     #
-    # Returns true if it is.
-    def client_id_configured?
-      @client_id.is_a?(String) && !@client_id.empty?
+    # Returns the resulting parsed JSON of the request
+    def post_with_auth(path, payload)
+      auth = { client_id: @client_id,
+               secret: @secret }
+      Plaid::Connect.post(File.join(@env, path), payload.merge(auth))
     end
 
-    # Public: Check if client_id is configured.
+    # Public: Make a post request with appended public key field.
+    #
+    # path    - Path or URL to make the request to.
+    # payload - The payload or data to post.
     #
-    # Returns true if it is.
-    def secret_configured?
-      @secret.is_a?(String) && !@secret.empty?
+    # Returns the resulting parsed JSON of the request.
+    def post_with_public_key(path, payload)
+      public_key = { public_key: @public_key }
+      Plaid::Connect.post(File.join(@env, path), payload.merge(public_key))
     end
   end
 end

data/lib/plaid/connect.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'net/http'
+require 'uri'
+
+require_relative 'version'
+
+module Plaid
+  # Internal: A module encapsulating HTTP post requests
+  module Connect
+    # Internal: Headers used for correct request and SDK tracking.
+    NETWORK_HEADERS = { 'User-Agent'   => "Plaid Ruby v#{Plaid::VERSION}",
+                        'Content-Type' => 'application/json' }.freeze
+
+    # Internal: Default read timeout for HTTP calls in seconds.
+    NETWORK_TIMEOUT = 600
+
+    # Internal: Run POST request on path with payload.
+    #
+    # path    - The path to send the request to.
+    # payload - The hash with data.
+    #
+    # Returns the parsed JSON response body.
+    def self.post(path, payload)
+      uri = URI.parse(path)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      http.read_timeout = Plaid::Connect::NETWORK_TIMEOUT
+
+      request = Net::HTTP::Post.new(uri.path, Plaid::Connect::NETWORK_HEADERS)
+      request.body = JSON.generate(payload)
+
+      Plaid::Connect.run http, request
+    end
+
+    # Internal: Run the request and process the response.
+    #
+    # http    - Object created by Net::HTTP.new
+    # request - Object created by Net::HTTP::Post.new (for POST)
+    #
+    # Returns the parsed JSON body or raises an appropriate PlaidError
+    def self.run(http, request)
+      response = http.request(request)
+
+      if response.body.nil? || response.body.empty?
+        raise Plaid::PlaidError.new(0, 'Server error', 'Try to connect later')
+      end
+
+      # All responses are expected to have a JSON body, so we always parse,
+      # not looking at the status code.
+      body = JSON.parse(response.body)
+
+      case response
+      when Net::HTTPSuccess
+        body
+      else
+        raise_error(body)
+      end
+    end
+
+    # Internal: Raise an error with the class depending on reponse body.
+    #
+    # body - A parsed response body with error.
+    #
+    # Raises a PlaidError
+    def self.raise_error(body)
+      raise Plaid::Error.error_from_type(body['error_type']).new(body['error_type'],
+                                                                 body['error_code'],
+                                                                 body['error_message'],
+                                                                 body['display_message'],
+                                                                 body['request_id'])
+    end
+  end
+end

data/lib/plaid/errors.rb

@@ -1,37 +1,73 @@
 module Plaid
-  # Public: Exception to throw when there are configuration problems
-  class NotConfiguredError < StandardError; end
-
   # Internal: Base class for Plaid errors
   class PlaidError < StandardError
-    attr_reader :code, :resolve
+    attr_reader :error_type, :error_code, :error_message, :display_message, :request_id
 
-    # Internal: Initialize a error with proper attributes.
+    # Internal: Initialize an error with proper attributes
     #
-    # code    - The Integer code (e.g. 1501).
-    # message - The String message, describing the error.
-    # resolve - The String description how to fix the error.
-    def initialize(code, message, resolve)
-      @code = code
-      @resolve = resolve
-
-      super "Code #{@code}: #{message}. #{resolve}"
+    # error_type      - A broad categorization of the error
+    # error_code      - The particular error code
+    # error_message   - A developer-friendly representation of the error message
+    # display_message - A user-friendly representation of the error message
+    # request_id      - The ID of the request you made, can be used to escalate problems
+    def initialize(error_type, error_code, error_message, display_message, request_id)
+      @error_type      = error_type
+      @error_code      = error_code
+      @error_message   = error_message
+      @display_message = display_message
+      @request_id      = request_id
+
+      super "\n"\
+            "Error Type      : #{@error_type}\n"\
+            "Error Code      : #{@error_code}\n"\
+            "Error Message   : #{@error_message}\n"\
+            "Display Message : #{@display_message}\n"\
+            "Request ID      : #{@request_id}\n"
     end
   end
 
-  # Public: Exception which is thrown when Plaid API returns a 400 response.
-  class BadRequestError    < PlaidError; end
+  # Public: returned when the request is malformed and cannot be processed.
+  class InvalidRequestError    < PlaidError; end
 
-  # Public: Exception which is thrown when Plaid API returns a 401 response.
-  class UnauthorizedError  < PlaidError; end
+  # Public: returned when all fields are provided and are in the correct format,
+  #         but the values provided are incorrect in some way.
+  class InvalidInputError      < PlaidError; end
 
-  # Public: Exception which is thrown when Plaid API returns a 402 response.
-  class RequestFailedError < PlaidError; end
+  # Public: returned when the request is valid but has exceeded established rate limits.
+  class RateLimitExceededError < PlaidError; end
 
-  # Public: Exception which is thrown when Plaid API returns a 404 response.
-  class NotFoundError      < PlaidError; end
+  # Public: returned during planned maintenance windows and
+  #         in response to API internal server errors.
+  class APIError               < PlaidError; end
 
-  # Public: Exception which is thrown when Plaid API returns a response which
-  # is neither 2xx, nor 4xx. Presumably 5xx.
-  class ServerError        < PlaidError; end
+  # Public: indicates that information provided for the item (such as credentials or MFA)
+  #         may be invalid or that the item is not supported on Plaid's platform.
+  class ItemError              < PlaidError; end
+
+  # Internal: A module that provides utilities for errors.
+  module Error
+    # Internal: Map error_type to PlaidError
+    #
+    # Maps an error_type from an error HTTP response to an actual PlaidError class instance
+    #
+    # error_type - The type of the error as indicated by the error response body
+    #
+    # Returns an error class mapped from error_type
+    def self.error_from_type(error_type)
+      case error_type
+      when 'INVALID_REQUEST'
+        Plaid::InvalidRequestError
+      when 'INVALID_INPUT'
+        Plaid::InvalidInputError
+      when 'RATE_LIMIT_EXCEEDED_ERROR'
+        Plaid::RateLimitExceededError
+      when 'API_ERROR'
+        Plaid::APIError
+      when 'ITEM_ERROR'
+        Plaid::ItemError
+      else
+        Plaid::PlaidError
+      end
+    end
+  end
 end