authsignal-ruby 2.1.3 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 261ad3aa9e626f62f4b8ec843b0ec4516a157b083980cae0ed7c8641f16b5088
-  data.tar.gz: 56d2f9ad45e5f6330999034ee7ac4667f5864bd0a2a745941f11edca0e840395
+  metadata.gz: e2bf6c96e9f79775fa1d3db3deb5ec5258a8c651e1b4fb8c1c3740c3f5ebd5b6
+  data.tar.gz: 90124d4aa0b3111cd4b52424c78b16f208d4179991e8dcfc52f48fc735483bba
 SHA512:
-  metadata.gz: eac78f4ddab0dbb2d042c2d77ce424b512524cb0c1b31c5c956793e651441a4b2d93c1611a195eadfe53b4d377c1ad404a2190ee2b88add9a5867c40ba5c396e
-  data.tar.gz: a0178eda449c5707522d441d680fd7ea7586fa21694a4ca7ea14a24b83543b9cfbcdf0613a00c2ad7d5f9cc10465ac3d767c8449dad6a18aaa44e85298fe96cd
+  metadata.gz: 1cb34330978dc710806be016761805b82c7cc442ab58752baf33ff62bff64a4476c7f62fce114e10f3dae144c100ae4fe05d167cd66435d3d38fdcb3adb63612
+  data.tar.gz: 5dca5b72d6c09fa2bfe78768d451661f6bad5d1188257a6d7523f51f389956c51214af1250c2f318706274b080c9a9ada019ad2f5e246f0daface09e05351096

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.3.5

data/Gemfile.lock

@@ -1,26 +1,36 @@
 PATH
   remote: .
   specs:
-    authsignal-ruby (2.1.3)
-      httparty (~> 0.21.0)
+    authsignal-ruby (3.0.1)
+      faraday (>= 2)
+      faraday-retry (~> 2.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.8.0)
-      public_suffix (>= 2.0.2, < 5.0)
-    crack (0.4.5)
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    bigdecimal (3.1.8)
+    crack (1.0.0)
+      bigdecimal
       rexml
     diff-lcs (1.5.0)
-    hashdiff (1.0.1)
-    httparty (0.21.0)
-      mini_mime (>= 1.0.0)
-      multi_xml (>= 0.5.2)
-    mini_mime (1.1.5)
-    multi_xml (0.6.0)
-    public_suffix (4.0.7)
+    faraday (2.12.0)
+      faraday-net_http (>= 2.0, < 3.4)
+      json
+      logger
+    faraday-net_http (3.3.0)
+      net-http
+    faraday-retry (2.2.1)
+      faraday (~> 2.0)
+    hashdiff (1.1.1)
+    json (2.7.2)
+    logger (1.6.1)
+    net-http (0.4.1)
+      uri
+    public_suffix (6.0.1)
     rake (13.0.6)
-    rexml (3.2.5)
+    rexml (3.3.8)
     rspec (3.11.0)
       rspec-core (~> 3.11.0)
       rspec-expectations (~> 3.11.0)
@@ -34,7 +44,8 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
-    webmock (3.14.0)
+    uri (0.13.1)
+    webmock (3.24.0)
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
@@ -46,7 +57,7 @@ DEPENDENCIES
   authsignal-ruby!
   rake (~> 13.0)
   rspec (~> 3.2)
-  webmock (~> 3.14.0)
+  webmock (~> 3.14)
 
 BUNDLED WITH
    2.3.21

data/README.md

@@ -48,6 +48,12 @@ require 'authsignal'
 Authsignal.setup do |config|
     config.api_secret_key = ENV["AUTHSIGNAL_SECRET_KEY"]
     config.base_uri = "https://au.signal.authsignal.com/v1"
+
+    # If you would like the Authsignal client to retry requests due to network issues
+    config.retry = true # default value: false
+
+    # If you would like to inspect raw request/response in development
+    config.debug = true # default value: false
 end
 ```
 
@@ -57,12 +63,60 @@ Authsignal's server side signal API has four main api calls `track`, `get_action
 
 For more details on these api calls, refer to our [official Ruby SDK docs](https://docs.authsignal.com/sdks/server/ruby#track).
 
+Example:
+```ruby
+Authsignal.track user_id: 'AS_001', action: 'withdraw', idempotency_key: 'a_random_hash'
+
+# returns:
+# {
+#    success?: true,
+#    state: 'ALLOW',
+#    idempotency_key: 'a_random_hash',
+#    ... rest of payload ...
+# }
+```
+
+### Response & Error handling
+
+Authsignal client come with 2 flavors of responses, by default calling the signal APIs will returns payload in hash.
+
+Example:
+```ruby
+Authsignal.enroll_verified_authenticator user_id: 'AS_001',
+                                         authenticator: {
+                                           oob_channel: 'INVALID', email: 'joebloke@authsignal.com'
+                                         }
+
+# returns:
+# {
+#    success?: false,
+#    status: 400,
+#    error: 'invalid_request',
+#    error_description: '/body/oobChannel must be equal to one of the allowed values'
+# }
+```
+
+All signal APIs come with a bang(`!`) counterpart, which will raise `Authsignal::ApiError` when the request is unsuccessful.
+
+
+Example:
+```ruby
+Authsignal.enroll_verified_authenticator! user_id: 'AS_001',
+                                         authenticator: {
+                                           oob_channel: 'INVALID', email: 'joebloke@authsignal.com'
+                                         }
+
+# raise:
+# <Authsignal::ApiError: invalid_request status: 400, error: invalid_request, description: /body/oobChannel must be equal to one o...
+```
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` or `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+Log request/response against test server: `Authsignal.configuration.debug = true`
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/authsignal/api_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Authsignal
+  class ApiError < StandardError
+    attr_reader :status, :error, :description
+
+    def initialize(message = "An unexpected API error occurred", status, error, description)
+      @status      = status || 500
+      @error       = error
+      @description = description
+
+      super(message)
+    end
+
+    def to_s
+      "#{super} status: #{status}, error: #{error}, description: #{description}"
+    end
+  end
+end

data/lib/authsignal/client.rb

@@ -1,95 +1,102 @@
+require 'erb'
+
 module Authsignal
     class Client
         USER_AGENT = "Authsignal Ruby v#{Authsignal::VERSION}"
         NO_API_KEY_MESSAGE  = "No Authsignal API Secret Key Set"
-        include HTTParty
 
-        def handle_response(response)
-            unless response.success?
-              raise HTTParty::ResponseError, "Failed with status code #{response.code}"
-            end
-            response
-        end
+        RETRY_OPTIONS = {
+          max: 3,
+          interval: 0.1,
+          interval_randomness: 0.5,
+          backoff_factor: 2,
+        }.freeze
+        private_constant :RETRY_OPTIONS
 
-        def initialize
-            self.class.base_uri Authsignal.configuration.base_uri
+        def initialize(retry_options: RETRY_OPTIONS)
             @api_key = require_api_key
 
-            @headers = {
-                        "User-Agent" => USER_AGENT,
-                        'Content-Type' => 'application/json' 
-                        }
-        end
+            @client = Faraday.new do |builder|
+                builder.url_prefix = Authsignal.configuration.base_uri
+                builder.adapter :net_http
+                builder.request :authorization, :basic, @api_key, nil
 
-        def require_api_key
-            Authsignal.configuration.api_secret_key || print_api_key_warning
+                builder.headers['Accept'] = 'application/json'
+                builder.headers['Content-Type'] = 'application/json'
+                builder.headers['User-Agent'] = USER_AGENT
+
+                builder.request :json
+                builder.response :json, parser_options: { symbolize_names: true }
+
+                builder.use Middleware::JsonRequest
+                builder.use Middleware::JsonResponse
+
+                builder.request :retry, retry_options if Authsignal.configuration.retry
+                builder.response :logger, ::Logger.new(STDOUT), bodies: true if Authsignal.configuration.debug
+            end
         end
 
-        def track(action, options = {})
-            actionCode = action[:action]
-            idempotencyKey = ERB::Util.url_encode(action[:idempotencyKey])
-            userId = ERB::Util.url_encode(action[:userId])
-            body = action.except(:userId, :actionCode)
-            path = "/users/#{userId}/actions/#{actionCode}"
+        def track(event)
+            user_id = url_encode(event[:user_id])
+            action = event[:action]
 
-            post(path, query: options, body: JSON.generate(body))
+            path = "users/#{user_id}/actions/#{action}"
+            body = event.except(:user_id)
+
+            make_request(:post, path, body: body)
         end
 
         def get_user(user_id:, redirect_url: nil)
             if(redirect_url)
-                path = "/users/#{ERB::Util.url_encode(user_id)}?redirectUrl=#{redirect_url}"
+                path = "users/#{url_encode(user_id)}?redirectUrl=#{redirect_url}"
             else
-                path = "/users/#{ERB::Util.url_encode(user_id)}"
+                path = "users/#{url_encode(user_id)}"
             end
-            get(path)
+            make_request(:get, path)
         end
 
         def update_user(user_id:, user:)
-            post("/users/#{ERB::Util.url_encode(user_id)}", body: JSON.generate(user))
+            make_request(:post, "users/#{url_encode(user_id)}", body: user)
         end
 
         def delete_user(user_id:)
-            delete("/users/#{ERB::Util.url_encode(user_id)}")
+            make_request(:delete, "users/#{url_encode(user_id)}")
         end
 
-        def validate_challenge(user_id: nil, token:)
-            path = "/validate"
-
-            response = post(path, query: {}, body: { userId: user_id, token: token }.to_json)
+        def validate_challenge(user_id: nil, token:, action: nil)
+            path = "validate"
 
-            handle_response(response)
+            make_request(:post, path, body: { user_id: user_id, token: token, action: action })
         end
 
         def get_action(user_id, action, idempotency_key)
-            get("/users/#{ERB::Util.url_encode(user_id)}/actions/#{action}/#{ERB::Util.url_encode(idempotency_key)}")
+            make_request(:get, "users/#{url_encode(user_id)}/actions/#{action}/#{url_encode(idempotency_key)}")
         end
 
+        ##
+        # TODO: delete identify?
         def identify(user_id, user_payload)
-            post("/users/#{ERB::Util.url_encode(user_id)}", body: JSON.generate(user_payload))
+            make_request(:post , "users/#{url_encode(user_id)}", body: user_payload)
         end
 
         def enroll_verified_authenticator(user_id, authenticator)
-            post("/users/#{ERB::Util.url_encode(user_id)}/authenticators", body: JSON.generate(authenticator))
+            make_request(:post, "users/#{url_encode(user_id)}/authenticators", body: authenticator)
         end
 
         def delete_user_authenticator(user_id:, user_authenticator_id:)
-            delete("/users/#{ERB::Util.url_encode(user_id)}/authenticators/#{ERB::Util.url_encode(user_authenticator_id)}")
+            make_request(:delete, "users/#{url_encode(user_id)}/authenticators/#{url_encode(user_authenticator_id)}")
         end
 
-        def get(path, query: {})
-            self.class.get(path, headers: @headers, basic_auth: {username: @api_key})
-        end
+        private
 
-        def post(path, query: {}, body: {})
-            self.class.post(path, headers: @headers, body: body, basic_auth: {username: @api_key})
+        def make_request(method, path, body: nil, headers: nil)
+            @client.public_send(method, path, body, headers)
         end
 
-        def delete(path, query: {}, body: {})
-            self.class.delete(path, headers: @headers, body: body, basic_auth: {username: @api_key})
+        def url_encode(s)
+            ERB::Util.url_encode(s)
         end
 
-        private
-
         def version
             Authsignal.configuration.version
         end
@@ -97,5 +104,9 @@ module Authsignal
         def print_api_key_warning
             $stderr.puts(NO_API_KEY_MESSAGE)
         end
+
+        def require_api_key
+            Authsignal.configuration.api_secret_key || print_api_key_warning
+        end
     end
 end

data/lib/authsignal/configuration.rb

@@ -13,15 +13,18 @@ module Authsignal
         end
   
         config_option :api_secret_key
-
         config_option :base_uri
+        config_option :debug
+        config_option :retry
 
         def initialize
             @config_values = {}
       
             # set default attribute values
             @defaults = OpenStruct.new({
-                base_uri: 'https://signal.authsignal.com/v1/'
+                base_uri: 'https://signal.authsignal.com/v1/',
+                retry: false,
+                debug: false
             })
         end
 

data/lib/authsignal/middleware/json_request.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Authsignal
+  module Middleware
+    class JsonRequest < Faraday::Middleware
+      def on_request(env)
+        return if env.body.nil?
+
+        parsed_body = JSON.parse(env.body)
+        if parsed_body.is_a?(Hash)
+          env.body = camelcase_keys(parsed_body).to_json
+        end
+      rescue JSON::ParserError
+        # noop
+      end
+
+      private
+
+      def camelcase_keys(hash)
+        hash.transform_keys { |key| snake_to_camel(key.to_s).to_sym }
+      end
+
+      def snake_to_camel(str)
+        str.split('_').inject([]) do |buffer, e|
+          buffer.push(buffer.empty? ? e : e.capitalize)
+        end.join
+      end
+    end
+  end
+end

data/lib/authsignal/middleware/json_response.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Authsignal
+  module Middleware
+    class JsonResponse < Faraday::Middleware
+      def on_complete(env)
+        ##
+        # NOTE: Response header has "content-type: text/plain" atm
+        # Otherwise, we can safe guard with: env.response_headers['content-type'] =~ /application\/json/
+        parsed_body = JSON.parse(env.body)
+        if parsed_body.is_a?(Hash)
+          parsed_body.delete("actionCode") # Remove deprecated actionCode from response
+          env.body = transform_to_snake_case(parsed_body)
+        end
+      rescue JSON::ParserError
+        # noop
+      end
+
+      private
+
+      def underscore(camelcased)
+        return camelcased.to_s unless /[A-Z-]|::/.match?(camelcased)
+        word = camelcased.to_s.gsub("::", "/")
+        word.gsub!(/([A-Z])(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      def transform_to_snake_case(value)
+        case value
+        when Array
+          value.map { |v| transform_to_snake_case(v) }
+        when Hash
+          value.transform_keys! { |k| underscore(k).to_sym }
+          value.each do |key, val|
+            value[key] = transform_to_snake_case(val)
+          end
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/authsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Authsignal
-  VERSION = "2.1.3"
+  VERSION = "3.0.1"
 end

data/lib/authsignal.rb

@@ -1,10 +1,15 @@
-require "httparty"
-
+require "faraday"
+require "faraday/retry"
 require "authsignal/version"
 require "authsignal/client"
 require "authsignal/configuration"
+require "authsignal/api_error"
+require "authsignal/middleware/json_response"
+require "authsignal/middleware/json_request"
 
 module Authsignal
+    NON_API_METHODS = [:setup, :configuration, :default_configuration]
+
     class << self
         attr_writer :configuration
 
@@ -16,88 +21,94 @@ module Authsignal
             @configuration ||= Authsignal::Configuration.new
         end
 
-
         def default_configuration
             configuration.defaults
         end
 
         def get_user(user_id:, redirect_url: nil)
             response = Client.new.get_user(user_id: user_id, redirect_url: redirect_url)
-            response.transform_keys { |key| underscore(key) }.transform_keys(&:to_sym)
+
+            handle_response(response)
         end
 
         def update_user(user_id:, user:)
             response = Client.new.update_user(user_id: user_id, user: user)
-            response.transform_keys { |key| underscore(key) }.transform_keys(&:to_sym)
+
+            handle_response(response)
         end
 
         def delete_user(user_id:)
             response = Client.new.delete_user(user_id: user_id)
-            response.transform_keys { |key| underscore(key) }.transform_keys(&:to_sym)
+
+            handle_response(response)
         end
 
         def get_action(user_id:, action:, idempotency_key:)
             response = Client.new.get_action(user_id, action, idempotency_key)
-            response.transform_keys { |key| underscore(key) }.transform_keys(&:to_sym)
+
+            handle_response(response)
         end
 
         def enroll_verified_authenticator(user_id:, authenticator:)
-            authenticator = authenticator.transform_keys { |key| camelize(key) }
             response = Client.new.enroll_verified_authenticator(user_id, authenticator)
-            
-            if response["authenticator"]
-                response["authenticator"] = response["authenticator"].transform_keys { |key| underscore(key) }.transform_keys(&:to_sym)
-            end
-
-            response = response.transform_keys { |key| underscore(key) }.transform_keys(&:to_sym)
 
-            response
+            handle_response(response)
         end
 
         def delete_user_authenticator(user_id:, user_authenticator_id: )
             response = Client.new.delete_user_authenticator(user_id: user_id, user_authenticator_id: user_authenticator_id)
-            response.transform_keys { |key| underscore(key) }.transform_keys(&:to_sym)
+
+            handle_response(response)
         end
 
         def track(event, options={})
             raise ArgumentError, "Action Code is required" unless event[:action].to_s.length > 0
             raise ArgumentError, "User ID value" unless event[:user_id].to_s.length > 0
 
-            event = event.transform_keys { |key| camelize(key) }
+            response = Client.new.track(event)
+            handle_response(response)
+        end
 
-            response = Client.new.track(event, options)
-            success = response && response.success?
-            if success
-                puts("Tracked event! #{response.response.inspect}")
+        def validate_challenge(token:, user_id: nil, action: nil)
+            response = Client.new.validate_challenge(user_id: user_id, token: token, action: action)
+            
+            handle_response(response)
+        end
+
+        private
+
+        def handle_response(response)
+            if response.success?
+                handle_success_response(response)
             else
-                puts("Track failure! #{response.response.inspect} #{response.body}")
+                handle_error_response(response)
             end
-
-            response.transform_keys { |key| underscore(key) }.transform_keys(&:to_sym)
-        rescue => e
-            RuntimeError.new("Failed to track action")
-            false
         end
 
-        def validate_challenge(token:, user_id: nil)
-            response = Client.new.validate_challenge(user_id: user_id, token: token)
-            
-            return { user_id: response["userId"], is_valid: response["isValid"], state: response["state"], action: response["actionCode"] }
+        def handle_success_response(response)
+            response.body.merge(success?: true)
         end
 
-        private
-        def underscore(string)
-            string.gsub(/::/, '/').
-            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-            gsub(/([a-z\d])([A-Z])/,'\1_\2').
-            tr("-", "_").
-            downcase
+        def handle_error_response(response)
+            case response.body
+            when Hash
+                response.body.merge(status: response.status, success?: false)
+            else
+                { status: response&.status || 500, success?: false }
+            end
         end
+    end
+
+    methods = Authsignal.singleton_class.public_instance_methods(false)
+    (methods - NON_API_METHODS).each do |method|
+        define_singleton_method("#{method}!") do |*args, **kwargs|
+            send(method, *args, **kwargs).tap do |response|
+                status = response[:status]
+                err = response[:error]
+                desc = response[:error_description]
 
-        def camelize(symbol)
-            string = symbol.to_s
-            string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
-            string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::").to_sym
+                raise ApiError.new(err, status, err, desc) unless response[:success?]
+            end
         end
     end
 end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: authsignal-ruby
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 3.0.1
 platform: ruby
 authors:
 - justinsoong
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 2024-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.21.0
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.14.0
+        version: '3.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.14.0
+        version: '3.14'
 description: Authsignal is a passwordless authentication/multifactor authentication
   with modern factors like passkeys
 email:
@@ -75,6 +89,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".tool-versions"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -85,8 +100,11 @@ files:
 - bin/console
 - bin/setup
 - lib/authsignal.rb
+- lib/authsignal/api_error.rb
 - lib/authsignal/client.rb
 - lib/authsignal/configuration.rb
+- lib/authsignal/middleware/json_request.rb
+- lib/authsignal/middleware/json_response.rb
 - lib/authsignal/version.rb
 homepage: https://github.com/authsignal/authsignal-ruby
 licenses: