frodo 0.10.0

data/lib/frodo/errors.rb

@@ -0,0 +1,70 @@
+module Frodo
+  # Base class for Frodo errors
+  class Error < StandardError
+  end
+
+  # Base class for network errors
+  class RequestError < Error
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      super(message)
+      @message  = message
+      @response = response
+    end
+
+    def http_status
+      response.status
+    end
+
+    def message
+      [default_message, @message].compact.join(': ')
+    end
+
+    def default_message
+      nil
+    end
+  end
+
+  class ClientError < RequestError
+  end
+
+  class ServerError < RequestError
+  end
+
+  module Errors
+    ERROR_MAP = []
+
+    CLIENT_ERRORS = {
+      400 => "Bad Request",
+      401 => "Access Denied",
+      403 => "Forbidden",
+      404 => "Not Found",
+      405 => "Method Not Allowed",
+      406 => "Not Acceptable",
+      413 => "Request Entity Too Large",
+      415 => "Unsupported Media Type"
+    }
+
+    CLIENT_ERRORS.each do |code, message|
+      klass = Class.new(ClientError) do
+        send(:define_method, :default_message) { "#{code} #{message}" }
+      end
+      const_set(message.delete(' \-\''), klass)
+      ERROR_MAP[code] = klass
+    end
+
+    SERVER_ERRORS = {
+      500 => "Internal Server Error",
+      503 => "Service Unavailable"
+    }
+
+    SERVER_ERRORS.each do |code, message|
+      klass = Class.new(ServerError) do
+        send(:define_method, :default_message) { "#{code} #{message}" }
+      end
+      const_set(message.delete(' \-\''), klass)
+      ERROR_MAP[code] = klass
+    end
+  end
+end

data/lib/frodo/middleware/authentication/token.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Frodo
+  # Authentication middleware used if oauth_token and refresh_token are set
+  class Middleware::Authentication::Token < Frodo::Middleware::Authentication
+    def params
+      { grant_type: 'refresh_token',
+        refresh_token: @options[:refresh_token],
+        client_id: @options[:client_id],
+        client_secret: @options[:client_secret] }
+    end
+  end
+end

data/lib/frodo/middleware/authentication.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Frodo
+  # Faraday middleware that allows for on the fly authentication of requests.
+  # When a request fails (a status of 401 is returned), the middleware
+  # will attempt to either reauthenticate (username and password) or refresh
+  # the oauth access token (if a refresh token is present).
+  class Middleware::Authentication < Frodo::Middleware
+    autoload :Token,    'frodo/middleware/authentication/token'
+
+    # Rescue from 401's, authenticate then raise the error again so the client
+    # can reissue the request.
+    def call(env)
+      @app.call(env)
+    rescue Frodo::UnauthorizedError
+      authenticate!
+      raise
+    end
+
+    # Internal: Performs the authentication and returns the response body.
+    def authenticate!
+      response = connection.post '/common/oauth2/token' do |req|
+        req.body = encode_www_form(params)
+      end
+
+      if response.status >= 500
+        raise Frodo::ServerError, error_message(response)
+      elsif response.status != 200
+        raise Frodo::AuthenticationError, error_message(response)
+      end
+
+      @options[:oauth_token]  = response.body['access_token']
+      @options[:refresh_token]  = response.body['refresh_token']
+      @options[:authentication_callback]&.call(response.body)
+
+      response.body
+    end
+
+    # Internal: The params to post to the OAuth service.
+    def params
+      raise NotImplementedError
+    end
+
+    # Internal: Faraday connection to use when sending an authentication request.
+    def connection
+      @connection ||= Faraday.new(faraday_options) do |builder|
+        builder.use Faraday::Request::UrlEncoded
+        builder.response :json
+
+        if Frodo.log?
+          builder.use Frodo::Middleware::Logger,
+                      Frodo.configuration.logger,
+                      @options
+        end
+
+        builder.adapter @options[:adapter]
+      end
+    end
+
+    # Internal: The parsed error response.
+    def error_message(response)
+      "#{response.body['error']}: #{response.body['error_description']}"
+    end
+
+    # Featured detect form encoding.
+    # URI in 1.8 does not include encode_www_form
+    def encode_www_form(params)
+      if URI.respond_to?(:encode_www_form)
+        URI.encode_www_form(params)
+      else
+        params.map do |k, v|
+          k = CGI.escape(k.to_s)
+          v = CGI.escape(v.to_s)
+          "#{k}=#{v}"
+        end.join('&')
+      end
+    end
+
+    private
+
+    def faraday_options
+      { url: "https://#{@options[:host]}",
+        proxy: @options[:proxy_uri],
+        ssl: @options[:ssl] }
+    end
+  end
+end

data/lib/frodo/middleware/authorization.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Frodo
+  # Piece of middleware that simply injects the OAuth token into the request
+  # headers.
+  class Middleware::Authorization < Frodo::Middleware
+    AUTH_HEADER = 'Authorization'
+
+    def call(env)
+      env[:request_headers][AUTH_HEADER] = %(Bearer #{token})
+      @app.call(env)
+    end
+
+    def token
+      @options[:oauth_token]
+    end
+  end
+end

data/lib/frodo/middleware/caching.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Frodo
+  class Middleware::Caching < FaradayMiddleware::Caching
+    def call(env)
+      expire(cache_key(env)) unless use_cache?
+      super
+    end
+
+    def expire(key)
+      cache&.delete(key)
+    end
+
+    # We don't want to cache requests for different clients, so append the
+    # oauth token to the cache key.
+    def cache_key(env)
+      super(env) + hashed_auth_header(env)
+    end
+
+    def use_cache?
+      @options.fetch(:use_cache, true)
+    end
+
+    def hashed_auth_header(env)
+      Digest::SHA1.hexdigest(
+        env[:request_headers][Restforce::Middleware::Authorization::AUTH_HEADER]
+      )
+    end
+  end
+end

data/lib/frodo/middleware/custom_headers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Frodo
+  # Middleware that allows you to specify custom request headers
+  # when initializing Frodo client
+  class Middleware::CustomHeaders < Frodo::Middleware
+    def call(env)
+      headers = @options[:request_headers]
+      env[:request_headers].merge!(headers) if headers.is_a?(Hash)
+
+      @app.call(env)
+    end
+  end
+end

data/lib/frodo/middleware/gzip.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Frodo
+  # Middleware to uncompress GZIP compressed responses from Salesforce.
+  class Middleware::Gzip < Frodo::Middleware
+    ACCEPT_ENCODING_HEADER  = 'Accept-Encoding'
+    CONTENT_ENCODING_HEADER = 'Content-Encoding'
+    ENCODING                = 'gzip'
+
+    def call(env)
+      env[:request_headers][ACCEPT_ENCODING_HEADER] = ENCODING if @options[:compress]
+      @app.call(env).on_complete do |environment|
+        on_complete(environment)
+      end
+    end
+
+    def on_complete(env)
+      env[:body] = decompress(env[:body]) if gzipped?(env)
+    end
+
+    # Internal: Returns true if the response is gzipped.
+    def gzipped?(env)
+      env[:response_headers][CONTENT_ENCODING_HEADER] == ENCODING
+    end
+
+    # Internal: Decompresses a gzipped string.
+    def decompress(body)
+      Zlib::GzipReader.new(StringIO.new(body)).read
+    end
+  end
+end

data/lib/frodo/middleware/instance_url.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Frodo
+  # Middleware which asserts that the instance_url is always set
+  class Middleware::InstanceURL < Frodo::Middleware
+    def call(env)
+      # If the connection url_prefix isn't set, we must not be authenticated.
+      unless url_prefix_set?
+        raise Frodo::UnauthorizedError,
+              'Connection prefix not set'
+      end
+
+      @app.call(env)
+    end
+
+    def url_prefix_set?
+      !!(connection.url_prefix&.host)
+    end
+  end
+end

data/lib/frodo/middleware/logger.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Frodo
+  class Middleware::Logger < Faraday::Response::Middleware
+    extend Forwardable
+
+    def initialize(app, logger, options)
+      super(app)
+      @options = options
+      @logger = logger || begin
+        require 'logger'
+        ::Logger.new(STDOUT)
+      end
+    end
+
+    def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+    def call(env)
+      debug('request') do
+        dump url: env[:url].to_s,
+          method: env[:method],
+          headers: env[:request_headers],
+          body: env[:body]
+      end
+      super
+    end
+
+    def on_complete(env)
+      debug('response') do
+        dump status: env[:status].to_s,
+          headers: env[:response_headers],
+          body: env[:body]
+      end
+    end
+
+    def dump(hash)
+      "\n" + hash.map { |k, v| "  #{k}: #{v.inspect}" }.join("\n")
+    end
+  end
+end

data/lib/frodo/middleware/multipart.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Frodo
+  class Middleware::Multipart < Faraday::Request::UrlEncoded
+    self.mime_type = 'multipart/form-data'
+    DEFAULT_BOUNDARY  = "--boundary_string"
+    JSON_CONTENT_TYPE = { "Content-Type" => "application/json" }.freeze
+
+    def call(env)
+      match_content_type(env) do |params|
+        env[:request] ||= {}
+        env[:request][:boundary] ||= DEFAULT_BOUNDARY
+        env[:request_headers][CONTENT_TYPE] += ";boundary=#{env[:request][:boundary]}"
+        env[:body] = create_multipart(env, params)
+      end
+      @app.call env
+    end
+
+    def process_request?(env)
+      type = request_type(env)
+      env[:body].respond_to?(:each_key) && !env[:body].empty? && (
+        (type.empty? && has_multipart?(env[:body])) ||
+        type == self.class.mime_type
+      )
+    end
+
+    def has_multipart?(obj)
+      # string is an enum in 1.8, returning list of itself
+      if obj.respond_to?(:each) && !obj.is_a?(String)
+        (obj.respond_to?(:values) ? obj.values : obj).each do |val|
+          return true if val.respond_to?(:content_type) || has_multipart?(val)
+        end
+      end
+      false
+    end
+
+    def create_multipart(env, params)
+      boundary = env[:request][:boundary]
+      parts = []
+
+      # Fields
+      parts << Faraday::Parts::Part.new(
+        boundary,
+        'entity_content',
+        params.reject { |k, v| v.respond_to? :content_type }.to_json,
+        JSON_CONTENT_TYPE
+      )
+
+      # Files
+      params.each do |k, v|
+        next unless v.respond_to? :content_type
+        parts << Faraday::Parts::Part.new(boundary,
+                                          k.to_s,
+                                          v)
+      end
+
+      parts << Faraday::Parts::EpiloguePart.new(boundary)
+
+      body = Faraday::CompositeReadIO.new(parts)
+      env[:request_headers]['Content-Length'] = body.length.to_s
+      body
+    end
+  end
+end

data/lib/frodo/middleware/odata_headers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Frodo
+    # Middleware that allows you to specify custom request headers
+    # when initializing Frodo client
+    class Middleware::OdataHeaders < Frodo::Middleware
+      def call(env)
+        env[:request_headers].merge!({'OData-Version' => '4.0', 'Content-type' => 'application/json'})
+
+        @app.call(env)
+      end
+    end
+  end

data/lib/frodo/middleware/raise_error.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Frodo
+  class Middleware::RaiseError < Faraday::Response::Middleware
+    def on_complete(env)
+      @env = env
+
+      case env[:status]
+      when 300
+        raise Faraday::Error::ClientError.new("300: The external ID provided matches " \
+                                              "more than one record",
+                                              response_values)
+      when 401
+        raise Frodo::UnauthorizedError, message
+      when 404
+        raise Faraday::Error::ResourceNotFound, message
+      when 413
+        raise Faraday::Error::ClientError.new("413: Request Entity Too Large",
+                                              response_values)
+      when 400...600
+        raise Faraday::Error::ClientError.new(message, response_values)
+      end
+    end
+
+    def message
+      "#{body['error']['code']}: #{body['error']['message']}"
+    end
+
+    def body
+      @body = (@env[:body].is_a?(Array) ? @env[:body].first : @env[:body])
+
+      case @body
+      when Hash
+        @body
+      else
+        { 'error' => {'code' => '(error code missing)', 'message' => @body}}
+      end
+    end
+
+    def response_values
+      {
+        status: @env[:status],
+        headers: @env[:response_headers],
+        body: @env[:body]
+      }
+    end
+  end
+end

data/lib/frodo/middleware.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Frodo
+  # Base class that all middleware can extend. Provides some convenient helper
+  # functions.
+  class Middleware < Faraday::Middleware
+    autoload :RaiseError,     'frodo/middleware/raise_error'
+    autoload :Authentication, 'frodo/middleware/authentication'
+    autoload :Authorization,  'frodo/middleware/authorization'
+    autoload :InstanceURL,    'frodo/middleware/instance_url'
+    autoload :Multipart,      'frodo/middleware/multipart'
+    autoload :Caching,        'frodo/middleware/caching'
+    autoload :Logger,         'frodo/middleware/logger'
+    autoload :Gzip,           'frodo/middleware/gzip'
+    autoload :CustomHeaders,  'frodo/middleware/custom_headers'
+
+    def initialize(app, client, options)
+      @app = app
+      @client = client
+      @options = options
+    end
+
+    # Internal: Proxy to the client.
+    def client
+      @client
+    end
+
+    # Internal: Proxy to the client's faraday connection.
+    def connection
+      client.send(:connection)
+    end
+  end
+end

data/lib/frodo/navigation_property/proxy.rb

@@ -0,0 +1,80 @@
+module Frodo
+  class NavigationProperty
+    class Proxy
+      def initialize(entity, nav_name)
+        @entity = entity
+        @nav_name = nav_name
+      end
+
+      def value=(value)
+        @value = value
+      end
+
+      def value
+        if link.nil?
+          if nav_property.nav_type == :collection
+            []
+          else
+            nil
+          end
+        else
+          @value ||= fetch_result
+        end
+      end
+
+      private
+
+      attr_reader :entity, :nav_name
+
+      def service
+        @service ||= Frodo::ServiceRegistry[entity.service_name]
+      end
+
+      def namespace
+        @namespace ||= service.namespace
+      end
+
+      def schema
+        @schema ||= service.schemas[namespace]
+      end
+
+      def entity_type
+        @entity_type ||= entity.name
+      end
+
+      def link
+        entity.links[nav_name]
+      end
+
+      def nav_property
+        schema.navigation_properties[entity_type][nav_name]
+      end
+
+      def fetch_result
+        raise "Invalid navigation link for #{nav_name}" unless link[:href]
+
+        options = {
+          type:         nav_property.entity_type,
+          namespace:    namespace,
+          service_name: entity.service_name
+        }
+        entity_set = Struct.new(:service, :entity_options)
+                           .new(entity.service, options)
+
+        query = Frodo::Query.new(entity_set)
+        begin
+          result = query.execute(link[:href])
+        rescue => ex
+          raise ex unless ex.message =~ /Not Found/
+          result = []
+        end
+
+        if nav_property.nav_type == :collection
+          result
+        else
+          result.first
+        end
+      end
+    end
+  end
+end

data/lib/frodo/navigation_property.rb

@@ -0,0 +1,29 @@
+require 'frodo/navigation_property/proxy'
+
+module Frodo
+  class NavigationProperty
+    attr_reader :name, :type, :nullable, :partner
+
+    def initialize(options)
+      @name     = options[:name] or raise ArgumentError, 'Name is required'
+      @type     = options[:type] or raise ArgumentError, 'Type is required'
+      @nullable = options[:nullable] || true
+      @partner  = options[:partner]
+    end
+
+    def nav_type
+      @nav_type ||= type =~ /^Collection/ ? :collection : :entity
+    end
+
+    def entity_type
+      @entity_type ||= type.split(/[()]/).last
+    end
+
+    def self.build(nav_property_xml)
+      options = nav_property_xml.attributes.map do |name, attr|
+        [name.downcase.to_sym, attr.value]
+      end.to_h
+      new(options)
+    end
+  end
+end

data/lib/frodo/properties/binary.rb

@@ -0,0 +1,50 @@
+module Frodo
+  module Properties
+    # Defines the Binary Frodo type.
+    class Binary < Frodo::Property
+      # Returns the property value, properly typecast
+      # @return [Integer,nil]
+      def value
+        if (@value.nil? || @value.empty?) && allows_nil?
+          nil
+        else
+          @value.to_i
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [0,1,Boolean]
+      def value=(new_value)
+        validate(new_value)
+        @value = parse_value(new_value)
+      end
+
+      # The Frodo type name
+      def type
+        'Edm.Binary'
+      end
+
+      # Value to be used in URLs.
+      # @return [String]
+      def url_value
+        "binary'#{value}'"
+      end
+
+      private
+
+      def parse_value(value)
+        if value == 0 || value == '0' || value == false
+          '0'
+        else
+          '1'
+        end
+      end
+
+      def validate(value)
+        unless [0,1,'0','1',true,false].include?(value)
+          validation_error 'Value is outside accepted range: 0 or 1'
+        end
+      end
+    end
+  end
+end

data/lib/frodo/properties/boolean.rb

@@ -0,0 +1,37 @@
+module Frodo
+  module Properties
+    # Defines the Boolean Frodo type.
+    class Boolean < Frodo::Property
+      # Returns the property value, properly typecast
+      # @return [Boolean, nil]
+      def value
+        if (@value.nil? || @value.empty?) && allows_nil?
+          nil
+        else
+          (@value == 'true' || @value == '1')
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [Boolean]
+      def value=(new_value)
+        validate(new_value)
+        @value = new_value.to_s
+      end
+
+      # The Frodo type name
+      def type
+        'Edm.Boolean'
+      end
+
+      private
+
+      def validate(value)
+        return if value.nil? && allows_nil?
+        unless [0,1,'0','1','true','false',true,false].include?(value)
+          validation_error 'Value is outside accepted range: true or false'
+        end
+      end
+    end
+  end
+end