iron_bank 0.1.0 → 0.7.1

data/lib/iron_bank/client.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module IronBank
+  # Handle the credentials to Zuora and establish a connection when making an
+  # authenticated request, reusing the same session cookie for future requests.
+  #
+  class Client
+    include IronBank::Instrumentation
+    include IronBank::OpenTracing
+
+    # Generic client error.
+    #
+    class Error < StandardError; end
+
+    # Thrown when the base_url cannot be found for the given domain.
+    #
+    class InvalidHostname < Error; end
+
+    # Alias each actions as a `Client` instance method
+    IronBank::Actions.constants.each do |action|
+      method_name = IronBank::Utils.underscore(action)
+      klass       = IronBank::Actions.const_get(action)
+
+      define_method :"#{method_name}" do |args|
+        klass.call(args)
+      end
+    end
+
+    def initialize(domain:, client_id:, client_secret:, auth_type: 'token')
+      @domain        = domain
+      @client_id     = client_id
+      @client_secret = client_secret
+      @auth_type     = auth_type
+    end
+
+    def inspect
+      %(#<IronBank::Client:0x#{(object_id << 1).to_s(16)} domain="#{domain}">)
+    end
+
+    def connection
+      validate_domain
+      reset_connection if auth.expired?
+
+      @connection ||= Faraday.new(faraday_config) do |conn|
+        conn.use      :ddtrace, open_tracing_options if open_tracing_enabled?
+        conn.use      instrumenter, instrumenter_options if instrumenter
+        conn.use      IronBank::Response::RaiseError
+        conn.request  :json
+        conn.response :logger, IronBank.logger
+        conn.response :json, content_type: /\bjson$/
+        conn.adapter  Faraday.default_adapter
+      end
+    end
+
+    def describe(object_name)
+      IronBank::Describe::Object.from_connection(connection, object_name)
+    end
+
+    private
+
+    attr_reader :domain, :client_id, :client_secret, :auth_type
+
+    def auth
+      @auth ||= IronBank::Authentication.new(
+        client_id:     client_id,
+        client_secret: client_secret,
+        base_url:      base_url,
+        auth_type:     auth_type
+      )
+    end
+
+    def base_url
+      @base_url ||= IronBank::Endpoint.base_url(domain)
+    end
+
+    def faraday_config
+      {
+        url:     base_url,
+        headers: headers
+      }
+    end
+
+    def headers
+      { 'Content-Type' => 'application/json' }.merge(auth.header)
+    end
+
+    def reset_connection
+      @connection = nil
+      auth.renew_session
+    end
+
+    def validate_domain
+      raise InvalidHostname, domain.to_s unless base_url
+    end
+  end
+end

data/lib/iron_bank/collection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module IronBank
+  # Collection class which allows records reloadable from the source
+  class Collection
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@records,
+                   :[],
+                   :each,
+                   :length,
+                   :size
+
+    def initialize(klass, conditions, records)
+      @klass = klass
+      @conditions = conditions
+      @records = records
+    end
+
+    # Update records from source
+    def reload
+      @records = @klass.where(@conditions)
+    end
+
+    # In case you need to access all array methods
+    def to_a
+      @records
+    end
+  end
+end

data/lib/iron_bank/configuration.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module IronBank
+  # The Zuora configuration class.
+  #
+  class Configuration
+    # Instrumentation
+    attr_accessor :instrumenter
+    attr_accessor :instrumenter_options
+
+    # Logger
+    attr_accessor :logger
+
+    # The Zuora domain for our tenant (apisandbox, production, etc.).
+    attr_accessor :domain
+
+    # OAuth client ID associated with our platform admin user.
+    attr_accessor :client_id
+
+    # OAuth client secret.
+    attr_accessor :client_secret
+
+    # Auth type (cookie|token)
+    attr_accessor :auth_type
+
+    # Cache store instance, optionally used by certain resources.
+    attr_accessor :cache
+
+    # Open Tracing
+    attr_accessor :open_tracing_enabled
+
+    # Open Tracing service name
+    attr_accessor :open_tracing_service_name
+
+    # Directory where the XML describe files are located.
+    attr_reader :schema_directory
+
+    # Directory where the local records are exported.
+    attr_reader :export_directory
+
+    def initialize
+      @schema_directory          = './config/schema'
+      @export_directory          = './config/export'
+      @logger                    = IronBank::Logger.new
+      @auth_type                 = 'token'
+      @open_tracing_enabled      = false
+      @open_tracing_service_name = 'ironbank'
+    end
+
+    def schema_directory=(value)
+      @schema_directory = value
+
+      return unless defined? IronBank::Schema
+
+      IronBank::Schema.reset
+
+      # Call `with_schema` on each resource to redefine accessors
+      IronBank::Resources.constants.each do |resource|
+        klass = IronBank::Resources.const_get(resource)
+        klass.with_schema if klass.is_a?(Class)
+      end
+    end
+
+    def export_directory=(value)
+      @export_directory = value
+      return unless defined? IronBank::Product
+
+      IronBank::LocalRecords::RESOURCES.each do |resource|
+        IronBank::Resources.const_get(resource).reset_store
+      end
+    end
+
+    def credentials
+      {
+        domain:        domain,
+        client_id:     client_id,
+        client_secret: client_secret,
+        auth_type:     auth_type
+      }
+    end
+
+    def credentials?
+      credentials.values.all?
+    end
+  end
+end

data/lib/iron_bank/csv.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module IronBank
+  # A custom CSV converter
+  #
+  class CSV < ::CSV
+    CSV::Converters[:decimal_integer] = lambda { |field|
+      begin
+        encoding = field.encode(CSV::ConverterEncoding)
+
+        # Match: [1, 10, 100], No match: [0.1, .1, 1., 0b10]
+        encoding =~ /^[+-]?\d+$/ ? encoding.to_i : field
+      rescue # encoding or integer conversion
+        field
+      end
+    }
+
+    CSV::Converters[:decimal_float] = lambda { |field|
+      begin
+        encoding = field.encode(CSV::ConverterEncoding)
+
+        # Match: [1.0, 1., 0.1, .1], No match: [1, 0b10]
+        encoding =~ /^[+-]?(?:\d*\.|\.\d*)\d*$/ ? encoding.to_f : field
+      rescue # encoding or float conversion
+        field
+      end
+    }
+  end
+end

data/lib/iron_bank/describe/field.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module IronBank
+  module Describe
+    # Describe a field in Zuora: name, label, type, etc.
+    #
+    class Field
+      private_class_method :new
+
+      TEXT_VALUES = %i[
+        name
+        label
+        type
+      ].freeze
+
+      PLURAL_VALUES = %i[
+        options
+        contexts
+      ].freeze
+
+      BOOLEAN_VALUES = %i[
+        selectable
+        createable
+        updateable
+        filterable
+        custom
+        required
+      ].freeze
+
+      def self.from_xml(doc)
+        new(doc)
+      end
+
+      # Defined separately because the node name is not ruby-friendly
+      def max_length
+        doc.at_xpath('.//maxlength').text.to_i
+      end
+
+      TEXT_VALUES.each do |val|
+        define_method(val) { doc.at_xpath(".//#{val}").text }
+      end
+
+      PLURAL_VALUES.each do |val|
+        singular = val.to_s.chop
+        define_method(val) { doc.xpath(".//#{val}/#{singular}").map(&:text) }
+      end
+
+      BOOLEAN_VALUES.each do |val|
+        define_method(:"#{val}?") { doc.at_xpath(".//#{val}").text == 'true' }
+      end
+
+      def inspect
+        "#<#{self.class}:0x#{(object_id << 1).to_s(16)} #{name} (#{type})>"
+      end
+
+      private
+
+      attr_reader :doc
+
+      def initialize(doc)
+        @doc = doc
+      end
+    end
+  end
+end

data/lib/iron_bank/describe/object.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module IronBank
+  module Describe
+    # Describe an object in Zuora: name, label, fields, etc.
+    #
+    class Object
+      # Raised when the XML does not provide the expected node (see #name)
+      #
+      class InvalidXML < StandardError; end
+
+      private_class_method :new
+
+      def self.from_xml(doc)
+        new(doc)
+      end
+
+      def self.from_connection(connection, name)
+        xml = connection.get("v1/describe/#{name}").body
+        new(Nokogiri::XML(xml))
+      rescue TypeError
+        # NOTE: Zuora returns HTTP 401 (unauthorized) roughly 1 out of 3 times
+        #       we make this call. Since this is a setup-only call and not a
+        #       runtime one, we deemed it acceptable to keep retrying until it
+        #       works.
+        retry
+      rescue IronBank::InternalServerError
+        # TODO: Need to properly store which object failed to be described by
+        #       Zuora API and send a report to the console.
+        nil
+      end
+
+      def export
+        File.open(file_path, 'w') { |file| file << doc.to_xml }
+      end
+
+      def name
+        node = doc.at_xpath('.//object/name')
+        raise InvalidXML unless node
+
+        node.text
+      end
+
+      def label
+        doc.at_xpath('.//object/label').text
+      end
+
+      def fields
+        @fields ||= doc.xpath('.//fields/field').map do |node|
+          IronBank::Describe::Field.from_xml(node)
+        end
+      end
+
+      def query_fields
+        @query_fields ||= fields.select(&:selectable?).map(&:name)
+      end
+
+      def related
+        @related ||= doc.xpath('.//related-objects/object').map do |node|
+          IronBank::Describe::Related.from_xml(node)
+        end
+      end
+
+      def inspect
+        "#<#{self.class}:0x#{(object_id << 1).to_s(16)} #{name}>"
+      end
+
+      private
+
+      attr_reader :doc
+
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def file_path
+        File.expand_path "#{name}.xml", IronBank.configuration.schema_directory
+      end
+    end
+  end
+end

data/lib/iron_bank/describe/related.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module IronBank
+  module Describe
+    # Describe a related object in Zuora, e.g., an account has a default payment
+    # method
+    #
+    class Related
+      private_class_method :new
+
+      def self.from_xml(doc)
+        new(doc)
+      end
+
+      def type
+        @type ||= doc.attributes['href'].value.split('/').last
+      end
+
+      def name
+        doc.at_xpath('.//name').text
+      end
+
+      def label
+        doc.at_xpath('.//label').text
+      end
+
+      def inspect
+        "#<#{self.class}:0x#{(object_id << 1).to_s(16)} #{name} (#{type})>"
+      end
+
+      private
+
+      attr_reader :doc
+
+      def initialize(doc)
+        @doc = doc
+      end
+    end
+  end
+end

data/lib/iron_bank/describe/tenant.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module IronBank
+  module Describe
+    # Describe a Zuora tenant, including its objects.
+    #
+    class Tenant
+      private_class_method :new
+
+      def self.from_xml(doc)
+        new(doc)
+      end
+
+      def self.from_connection(connection)
+        xml = connection.get('v1/describe').body
+        new(Nokogiri::XML(xml), connection)
+      rescue TypeError
+        # NOTE: Zuora returns HTTP 401 (unauthorized) roughly 1 out of 3 times
+        # we make this call. Since this is a setup-only call and not a runtime
+        # one, we deemed it acceptable to keep retrying until it works.
+        retry
+      end
+
+      def objects
+        return object_names unless connection
+
+        @objects ||= object_names.map do |name|
+          IronBank::Describe::Object.from_connection(connection, name)
+        end
+      end
+
+      def inspect
+        "#<#{self.class}:0x#{(object_id << 1).to_s(16)}>"
+      end
+
+      private
+
+      attr_reader :doc, :connection
+
+      def initialize(doc, connection = nil)
+        @doc        = doc
+        @connection = connection
+      end
+
+      def object_names
+        @object_names ||= doc.xpath('.//object/name').map(&:text)
+      end
+    end
+  end
+end

data/lib/iron_bank/endpoint.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module IronBank
+  # Identify and return the proper base URL for a given Zuora domain.
+  #
+  class Endpoint
+    private_class_method :new
+
+    PRODUCTION  = /\Arest\.zuora\.com\z/i
+    SERVICES    = /\Aservices(\d+)\.zuora\.com(:\d+)?\z/i
+    APISANDBOX  = /\Arest.apisandbox.zuora\.com\z/i
+
+    def self.base_url(domain = '')
+      new(domain).base_url
+    end
+
+    def base_url
+      case domain
+      when PRODUCTION
+        'https://rest.zuora.com/'
+      when SERVICES
+        "https://#{domain}/".downcase
+      when APISANDBOX
+        'https://rest.apisandbox.zuora.com/'
+      end
+    end
+
+    private
+
+    attr_reader :domain
+
+    def initialize(domain)
+      @domain = domain
+    end
+  end
+end

data/lib/iron_bank/error.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module IronBank
+  # Custom error class for rescuing from all Zuora API errors
+  class Error < StandardError
+    # Returns the appropriate IronBank::Error subclass based on status and
+    # response message
+    def self.from_response(response)
+      status = response[:status].to_i
+
+      klass = begin
+        case status
+        when 400      then IronBank::BadRequest
+        when 404      then IronBank::NotFound
+        when 429      then IronBank::TooManyRequests
+        when 500      then IronBank::InternalServerError
+        when 400..499 then IronBank::ClientError
+        when 500..599 then IronBank::ServerError
+        end
+      end
+
+      return unless klass
+
+      klass.new(response)
+    end
+  end
+
+  # Raised on errors in the 400-499 range
+  class ClientError < Error; end
+
+  # Raised when Zuora returns a 400 HTTP status code
+  class BadRequest < ClientError; end
+
+  # Raised when Zuora returns a 404 HTTP status code
+  class NotFound < ClientError; end
+
+  # Raised when Zuora returns a 429 HTTP status code
+  class TooManyRequests < ClientError; end
+
+  # Raised on errors in the 500-599 range
+  class ServerError < Error; end
+
+  # Raised when Zuora returns a 500 HTTP status code
+  class InternalServerError < ServerError; end
+end

data/lib/iron_bank/instrumentation.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module IronBank
+  # Instrumentation helper module
+  module Instrumentation
+    def instrumenter
+      IronBank.configuration.instrumenter
+    end
+
+    def instrumenter_options
+      IronBank.configuration.instrumenter_options || {}
+    end
+  end
+end

data/lib/iron_bank/local.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module IronBank
+  # A local store for exported records.
+  #
+  module Local
+    def find(id)
+      store[id] || super
+    end
+
+    def find_each
+      return enum_for(:find_each) unless block_given?
+
+      values = store.values
+      values.any? ? values.each { |record| yield record } : super
+    end
+
+    def all
+      store.any? ? store.values : super
+    end
+
+    def where(conditions)
+      records = store.values.select do |record|
+        conditions.all? { |field, value| record.public_send(field) == value }
+      end
+
+      records.any? ? records : super
+    end
+
+    def reset_store
+      @store = nil
+    end
+
+    private
+
+    def store
+      @store ||= File.exist?(file_path) ? load_records : {}
+    end
+
+    def load_records
+      CSV.foreach(file_path, csv_options).with_object({}) do |row, store|
+        # NOTE: when we move away from Ruby 2.2.x and 2.3.x we can uncomment
+        # this line, delete the other one, since `Hash#compact` is available in
+        # 2.4.x and we can remove two smells from `.reek` while we are at it
+        #
+        # store[row['Id']] = new(row.to_h.compact)
+        store[row['Id']] = new(row.to_h.reject { |_, value| value.nil? })
+      end
+    end
+
+    def csv_options
+      {
+        headers:    true,
+        converters: csv_converters
+      }
+    end
+
+    def csv_converters
+      %i[
+        decimal_integer
+        decimal_float
+      ]
+    end
+
+    def file_path
+      File.expand_path(
+        "#{object_name}.csv",
+        IronBank.configuration.export_directory
+      )
+    end
+  end
+end

data/lib/iron_bank/local_records.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module IronBank
+  # Utility class to save records locally.
+  #
+  class LocalRecords
+    private_class_method :new
+
+    RESOURCES = %w[
+      Product
+      ProductRatePlan
+      ProductRatePlanCharge
+      ProductRatePlanChargeTier
+    ].freeze
+
+    def self.directory
+      IronBank.configuration.export_directory
+    end
+
+    def self.export
+      FileUtils.mkdir_p(directory) unless Dir.exist?(directory)
+      RESOURCES.each { |resource| new(resource).export }
+    end
+
+    def export
+      CSV.open(file_path, 'w') do |csv|
+        csv << klass.fields # headers
+        write_records(csv)
+      end
+    end
+
+    private
+
+    attr_reader :resource
+
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def klass
+      IronBank::Resources.const_get(resource)
+    end
+
+    def file_path
+      File.expand_path("#{resource}.csv", self.class.directory)
+    end
+
+    def write_records(csv)
+      klass.find_each { |record| csv << record.to_csv_row }
+    end
+  end
+end