setsuzoku 0.10.12 → 0.11.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39fda212a16a449e09d41daff1b4dac7188dadcee5e179f8feb5bf28449aa662
-  data.tar.gz: ba5b6a928f35b2cf319ee0cac4569d72f14ed5c3d11e52ed48bbfb05bd78aa4b
+  metadata.gz: 5ce2db23193b6cfc30d0286a655c29686d0c4a65b9f11d102fb4626354730c00
+  data.tar.gz: 2ed86eb0454c3c2576bca8ab2e7b5103d0ebd3cb59eaa055cbcaf59fe20c4a5f
 SHA512:
-  metadata.gz: 9ad9ee7d67eedf16c91549dd7e12ecd18e6783f6debbe1615259e5d183ff4eb3367b46cbfae092645394958f3d57ffaeb8ac29c30b42b3aa725dd83231192c7a
-  data.tar.gz: 9eedaf2642a3537d5c02284578319ec859329425d47ebfade8a7793c169b7e019dca0d0f0d4a6435cf05e93768190622dc7ce2e3fed53895f6b2fbb30cf9b85b
+  metadata.gz: c119e54f7b79cfcde12566681a236af85c0d8b06a06b3fe58087d52663477475f54b28077134b4074293d073a0ff058a9e8d88ba1faccde2db904012d8e8c85f
+  data.tar.gz: 4d1e2288730612ef2aa9845f642d1473d2b518e7d29561e27fffe68ac11fbba2c61e9b4052a0666ba03492b451236f0274593b687a3fd11ee7ce160f2714868f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    setsuzoku (0.10.12)
+    setsuzoku (0.11.8)
       activesupport (~> 5.0)
       faraday (~> 0.11)
       httparty (~> 0.16.4)
@@ -18,7 +18,7 @@ GEM
       tzinfo (~> 1.1)
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
-    concurrent-ruby (1.1.6)
+    concurrent-ruby (1.1.7)
     crack (0.4.3)
       safe_yaml (~> 1.0.0)
     diff-lcs (1.4.2)
@@ -28,7 +28,7 @@ GEM
     httparty (0.16.4)
       mime-types (~> 3.0)
       multi_xml (>= 0.5.2)
-    i18n (1.8.3)
+    i18n (1.8.5)
       concurrent-ruby (~> 1.0)
     mime-types (3.3.1)
       mime-types-data (~> 3.2015)
@@ -37,7 +37,7 @@ GEM
     minitest (5.14.1)
     multi_xml (0.6.0)
     multipart-post (2.1.1)
-    nokogiri (1.10.9)
+    nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
     public_suffix (4.0.5)
     rake (10.5.0)
@@ -57,7 +57,7 @@ GEM
     safe_yaml (1.0.5)
     sorbet (0.5.5675)
       sorbet-static (= 0.5.5675)
-    sorbet-runtime (0.5.5862)
+    sorbet-runtime (0.5.5878)
     sorbet-static (0.5.5675-universal-darwin-14)
     thread_safe (0.3.6)
     tzinfo (1.2.7)

data/lib/setsuzoku/api_response.rb

@@ -4,7 +4,7 @@
 module Setsuzoku
   # The generic API response object that all API responses should return.
   class ApiResponse < T::Struct
-    prop :data, T.nilable(T::Hash[Symbol, T.untyped]), default: {}
+    prop :data, T.nilable(T.untyped), default: {}
     prop :success, T::Boolean, default: false
     prop :error, T.nilable(String), default: nil
   end

data/lib/setsuzoku/api_strategy.rb

@@ -80,7 +80,7 @@ module Setsuzoku
       self.external_api_handler.call_external_api_wrapper(plugin: self.plugin, request: request, action_details: action_details) do
         begin
           # raise if the token is invalid and needs refreshed, but don't raise if we are trying to get a refresh token
-          raise Setsuzoku::Exception::InvalidAuthCredentials.new unless (request.action == :refresh_token || self.auth_strategy.auth_credential_valid?)
+          raise Setsuzoku::Exception::InvalidAuthCredentials.new unless (strategy == :auth || self.auth_strategy.auth_credential_valid?)
           raw_response = self.perform_external_call(request: request, action_details: action_details, **options)
           formatted_response = self.parse_response(response: raw_response, response_type: action_details[:actions][request.action][:response_type])
           success = true
@@ -118,7 +118,7 @@ module Setsuzoku
     # @param options [Hash] the parsing options. Generally the response_type. e.g. :xml, :json
     #
     # @return [Hash] the parsed hash of the response object.
-    sig { abstract.params(response: T.untyped, options: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+    sig { abstract.params(response: T.untyped, options: T.untyped).returns(T.untyped) }
     def parse_response(response:, **options); end
   end
 end

data/lib/setsuzoku/credential.rb

@@ -14,6 +14,12 @@ module Setsuzoku
     sig { abstract.returns(Struct) }
     def self.stub_credential; end
 
+    # The status of the credential.
+    #
+    # @return [Hash] the status of the credential.
+    sig { abstract.returns(String) }
+    def status; end
+
     # A settings object for the credential.
     #
     # @return [Hash] the settings for the credential.

data/lib/setsuzoku/rspec/dynamic_spec_helper.rb

@@ -2,6 +2,8 @@
 
 require 'active_support/core_ext/class/subclasses'
 require 'active_support/inflector/methods'
+require 'faraday'
+
 module Setsuzoku
   module DynamicSpecHelper
 
@@ -150,20 +152,21 @@ module Setsuzoku
         stub.each do |action_name, props|
           props.each do |propz|
             plugin.api_strategy.current_action = action_name
-            default_headers = plugin.api_strategy.request_options(propz[:request_format])[:headers] || { 'Authorization' => 'Bearer stubbed_token', 'Content-Type' => "application/#{propz[:request_format]}" }
+            default_headers = plugin.api_strategy.request_options(propz[:request_format])[:headers] || { 'Content-Type' => "application/#{propz[:request_format]}" }
             if plugin.auth_strategy.is_a?(Setsuzoku::Service::WebService::AuthStrategies::BasicAuthStrategy)
               basic_auth = plugin.api_strategy.request_options(propz[:request_format])[:basic_auth]
               auth_header = { 'Authorization' => "Basic #{Base64.encode64("#{basic_auth[:username]}:#{basic_auth[:password]}").gsub("\n", '')}" }
-              default_headers.merge!(auth_header)
+            elsif plugin.auth_strategy.is_a?(Setsuzoku::Service::WebService::AuthStrategies::OAuthStrategy)
+              auth_header = { 'Authorization' => "Bearer #{plugin.api_strategy.request_options(propz[:request_format])[:token]}" }
             end
+            default_headers.merge!(auth_header) if auth_header
             headers = propz[:headers] ? [propz[:headers]] : [default_headers]
             stub_directory ||= "#{plugin.class.plugin_namespace}/#{provider}"
+
             headers.each do |header|
-              header = {
-                  'Accept'=>'*/*',
-                  'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-                  'User-Agent'=>'Ruby'
-              }.merge(header.deep_stringify_keys)
+              header = Faraday.new.headers
+                        .merge({'Accept'=>'*/*','Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'})
+                        .merge(header.deep_stringify_keys)
 
               if propz[:stub_data]
                 # we have specified specific stub data for this action

data/lib/setsuzoku/service/web_service/api_strategies/rest_strategy.rb

@@ -33,7 +33,7 @@ module Setsuzoku
           #   media_type - 'json'
           #
           # @return [Hash] the parsed response object.
-          sig { override.params(request: T.untyped, action_details: T::Hash[T.untyped, T.untyped], options: T.untyped).returns(Faraday::Response) }
+          sig { override.params(request: RestAPIRequest, action_details: T::Hash[T.untyped, T.untyped], options: T.untyped).returns(Faraday::Response) }
           def perform_external_call(request:, action_details:, **options)
             request_properties = self.get_request_properties(action_name: request.action, action_details: action_details, req_params: request.body)
             request_options = self.request_options(request_properties[:request_format], action_details[:actions][request.action])
@@ -43,11 +43,14 @@ module Setsuzoku
             @faraday = Faraday.new(url: request_properties[:formatted_full_url], request: { params_encoder: Faraday::FlatParamsEncoder }) do |faraday|
               faraday.request(:multipart) if options[:attachments].present?
               faraday.request(:url_encoded)
-              # faraday.basic_auth(request_options[:basic_auth][:username], request_options[:basic_auth][:password]) if request_options[:basic_auth]
-              faraday.request(:basic_auth, request_options[:basic_auth][:username], request_options[:basic_auth][:password]) if request_options[:basic_auth]
-              # faraday.response request_properties[:response_format] if request_properties[:response_format]
-              faraday.authorization(:Bearer, request_properties[:token]) if request_properties[:token]
-              # request_options[:headers][:Authorization].prepend('Bearer ') if request_options[:headers][:Authorization]
+              #TODO: change these to faraday = self.auth_strategy.set_authorization!(request: faraday)
+              unless request.without_headers
+                if request_options[:token]
+                  faraday.authorization(:Bearer, request_options[:token])
+                elsif request_options[:basic_auth]
+                  faraday.request(:basic_auth, request_options[:basic_auth][:username], request_options[:basic_auth][:password])
+                end
+              end
               faraday.adapter Faraday.default_adapter
             end
 
@@ -60,7 +63,11 @@ module Setsuzoku
                 req.body = payload
               end
             else
-              @faraday.headers = request_options[:headers] if request_options[:headers]
+              if request.without_headers
+                @faraday.headers = {}
+              elsif request_options[:headers]
+                @faraday.headers = (@faraday.headers || {}).merge(request_options[:headers])
+              end
               resp = @faraday.send(request_properties[:request_method], request_properties[:formatted_full_url], full_request)
             end
             resp
@@ -81,7 +88,6 @@ module Setsuzoku
             request_method = request_method.downcase.to_sym
             request_format = action[:request_type]
             response_format = action[:response_type]
-            token = action[:token]
             stub_data = action[:stub_data] if for_stub
             full_url = url + endpoint
             formatted_full_url, req_params = self.replace_dynamic_vars(full_url: full_url, req_params: req_params)
@@ -93,7 +99,6 @@ module Setsuzoku
                 formatted_full_url: formatted_full_url,
                 req_params: req_params,
                 stub_data: stub_data,
-                token: token
             }
           end
 

data/lib/setsuzoku/service/web_service/api_strategy.rb

@@ -72,13 +72,15 @@ module Setsuzoku
         # @param options [Hash] the parsing options. Generally the response_type. e.g. :xml, :json
         #
         # @return [Hash] the parsed hash of the response object.
-        sig { override.params(response: Faraday::Response, options: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+        sig { override.params(response: Faraday::Response, options: T.untyped).returns(T.untyped) }
         def parse_response(response:, **options)
           case options[:response_type]
           when :json
             JSON.parse(response.body).deep_symbolize_keys
           when :xml
             convert_xml_to_hash(response.body)
+          when :html
+            response.body
           else
             JSON.parse(response.body).deep_symbolize_keys
           end

data/lib/setsuzoku/service/web_service/auth_strategies/o_auth_strategy.rb

@@ -31,9 +31,7 @@ module Setsuzoku
           sig { override.returns(T::Hash[Symbol, T.untyped]) }
           def auth_headers
             {
-                headers: {
-                    'Authorization': "Bearer #{self.credential.token}"
-                }
+              token: self.credential.token
             }
           end
 
@@ -73,7 +71,7 @@ module Setsuzoku
           # @return [Boolean] true if the token is invalid.
           sig { returns(T::Boolean) }
           def token_is_invalid?
-            active = self.credential.respond_to?(:"status") ? self.credential.status != 'disabled' : true
+            active = self.credential.status != 'disabled'
             active && !self.credential.expires_on.blank? &&
                 !self.credential.refresh_token.blank? &&
                 (self.credential.expires_on < refresh_before_expiration_time)
@@ -112,38 +110,32 @@ module Setsuzoku
           sig { params(body: T::Hash[Symbol, String], action: Symbol).void }
           def get_token!(body, action)
             success = false
-            request = self.api_strategy.request_class.new(action: action, body: body)
+            request = self.api_strategy.request_class.new(action: action, body: body, without_headers: true)
 
             resp = self.api_strategy.call_external_api(request: request, strategy: :auth)
 
+            attrs = {}
             if resp.data && resp.data[:access_token]
-              self.credential.status = 'active' if self.credential.respond_to?(:"status=")
-              self.credential.token = resp.data[:access_token]
-              self.credential.refresh_token = resp.data[:refresh_token] if resp.data.key?(:refresh_token)
-              self.credential.expires_on = if resp.data[:expires_in]
-                                             resp.data[:expires_in].to_i.seconds.from_now
-                                           # elsif resp.data[:issued_at] && self.class.token_valid_for
-                                           #   Time.at(resp.data[:issued_at].to_i / 1000) + self.class.token_valid_for
-                                           end
-
-              self.plugin.set_credential_fields!(resp) if self.plugin.respond_to?(:set_credential_fields!)
-
-              #TODO: figure out a better way to do this  when we add other integrations...
-              #
-              # if self.is_a?(FacebookIntegration)
-              #   resp = self.exchange_for_long_lived_token
-              #   if resp && resp.data['access_token']
-              #     self.token = resp.data['access_token']
-              #     self.refresh_token = resp.data['access_token']
-              #     self.expires_on = 59.days.from_now
-              #   end
-              # end
+              attrs[:status] = 'active'
+              attrs[:token] = resp.data[:access_token]
+              attrs[:refresh_token] = resp.data[:refresh_token] if resp.data.key?(:refresh_token)
+              attrs[:expires_on] = resp.data[:expires_in].to_i.seconds.from_now if resp.data[:expires_in]
+
+              plugin_attrs = self.plugin.credential_fields_to_update(resp) if self.plugin.respond_to?(:credential_fields_to_update)
+              attrs.merge!(plugin_attrs)
             else
-              self.credential.status = 'error' if self.credential.respond_to?(:"status=")
+              attrs[:status] = 'error'
             end
 
-            if self.credential.respond_to?(:"save")
-              self.credential.save && resp.success
+            # Only save Setsuzoku known fields, and any additional attributes the plugin specifies
+            # in credential_fields_to_update.
+            if self.credential.respond_to?(:"update_columns")
+              # we issue an update_columns instead of a save/update_attributes
+              # so as to only mutate these attributes
+              # and not any other fields that may have been set for the credential
+              save = self.credential.update_columns(attrs)
+              self.credential.touch if save && self.credential.respond_to?(:"touch")
+              save && resp.success
             else
               resp.success
             end

data/lib/setsuzoku/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Setsuzoku
-  VERSION = '0.10.12'
+  VERSION = '0.11.8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: setsuzoku
 version: !ruby/object:Gem::Version
-  version: 0.10.12
+  version: 0.11.8
 platform: ruby
 authors:
 - Luke Stadtler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-04 00:00:00.000000000 Z
+date: 2020-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler