identisure-client 0.1.0

data/lib/identisure/freja.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Identisure
+  module Freja
+    class AuthRequest
+      attr_reader :ssn, :callback_url, :min_registration_level, :org_number,
+                  :request_address, :ref_id
+
+      def initialize(ssn: nil, callback_url: nil, min_registration_level: nil,
+                     org_number: nil, request_address: nil, ref_id: nil)
+        @ssn = ssn; @callback_url = callback_url
+        @min_registration_level = min_registration_level; @org_number = org_number
+        @request_address = request_address; @ref_id = ref_id
+      end
+
+      def to_h
+        {
+          ssn: @ssn, callbackUrl: @callback_url,
+          minRegistrationLevel: @min_registration_level, orgNumber: @org_number,
+          requestAddress: @request_address, refId: @ref_id
+        }.compact
+      end
+    end
+
+    class BackchannelAuthRequest
+      attr_reader :ssn, :country, :callback_url, :min_registration_level,
+                  :org_number, :request_address, :ref_id
+
+      def initialize(ssn:, country:, callback_url: nil, min_registration_level: nil,
+                     org_number: nil, request_address: nil, ref_id: nil)
+        @ssn = ssn; @country = country; @callback_url = callback_url
+        @min_registration_level = min_registration_level; @org_number = org_number
+        @request_address = request_address; @ref_id = ref_id
+      end
+
+      def to_h
+        {
+          ssn: @ssn, country: @country, callbackUrl: @callback_url,
+          minRegistrationLevel: @min_registration_level, orgNumber: @org_number,
+          requestAddress: @request_address, refId: @ref_id
+        }.compact
+      end
+    end
+
+    class SignRequest
+      attr_reader :text, :ssn, :callback_url, :min_registration_level,
+                  :org_number, :request_address, :ref_id
+
+      def initialize(text:, ssn: nil, callback_url: nil, min_registration_level: nil,
+                     org_number: nil, request_address: nil, ref_id: nil)
+        @text = text; @ssn = ssn; @callback_url = callback_url
+        @min_registration_level = min_registration_level; @org_number = org_number
+        @request_address = request_address; @ref_id = ref_id
+      end
+
+      def to_h
+        {
+          text: @text, ssn: @ssn, callbackUrl: @callback_url,
+          minRegistrationLevel: @min_registration_level, orgNumber: @org_number,
+          requestAddress: @request_address, refId: @ref_id
+        }.compact
+      end
+    end
+
+    class BackchannelSignRequest
+      attr_reader :ssn, :country, :text, :callback_url, :min_registration_level,
+                  :org_number, :request_address, :ref_id
+
+      def initialize(ssn:, country:, text:, callback_url: nil, min_registration_level: nil,
+                     org_number: nil, request_address: nil, ref_id: nil)
+        @ssn = ssn; @country = country; @text = text; @callback_url = callback_url
+        @min_registration_level = min_registration_level; @org_number = org_number
+        @request_address = request_address; @ref_id = ref_id
+      end
+
+      def to_h
+        {
+          ssn: @ssn, country: @country, text: @text, callbackUrl: @callback_url,
+          minRegistrationLevel: @min_registration_level, orgNumber: @org_number,
+          requestAddress: @request_address, refId: @ref_id
+        }.compact
+      end
+    end
+
+    class Pending
+      attr_reader :id, :ref_id, :auto_start_token, :qr_data
+
+      def initialize(id:, auto_start_token:, qr_data:, ref_id: nil)
+        @id = id; @ref_id = ref_id
+        @auto_start_token = auto_start_token; @qr_data = qr_data
+      end
+
+      def deconstruct_keys(_)
+        { id: @id, ref_id: @ref_id, auto_start_token: @auto_start_token, qr_data: @qr_data }
+      end
+
+      def self.from_json(d)
+        new(id: d['id'], ref_id: d['refId'],
+            auto_start_token: d['autoStartToken'], qr_data: d['qrData'])
+      end
+    end
+
+    class Completed
+      attr_reader :id, :ref_id, :ssn, :country, :name, :given_name, :surname,
+                  :address, :company_signatory_text, :authenticated_at, :signed_at
+
+      def initialize(id:, ssn:, country:, name:, given_name:, surname:,
+                     ref_id: nil, address: nil, company_signatory_text: nil,
+                     authenticated_at: nil, signed_at: nil)
+        @id = id; @ref_id = ref_id; @ssn = ssn; @country = country
+        @name = name; @given_name = given_name; @surname = surname
+        @address = address; @company_signatory_text = company_signatory_text
+        @authenticated_at = authenticated_at; @signed_at = signed_at
+      end
+
+      def deconstruct_keys(_)
+        { id: @id, ref_id: @ref_id, ssn: @ssn, country: @country,
+          name: @name, given_name: @given_name, surname: @surname,
+          address: @address, company_signatory_text: @company_signatory_text,
+          authenticated_at: @authenticated_at, signed_at: @signed_at }
+      end
+
+      def self.from_json(d)
+        new(
+          id: d['id'], ref_id: d['refId'], ssn: d['ssn'], country: d['country'],
+          name: d['name'], given_name: d['givenName'], surname: d['surname'],
+          address: d['address'], company_signatory_text: d['companySignatoryText'],
+          authenticated_at: d['authenticatedAt'], signed_at: d['signedAt']
+        )
+      end
+    end
+
+    class Failed
+      attr_reader :id, :ref_id, :error
+
+      def initialize(id:, error:, ref_id: nil)
+        @id = id; @ref_id = ref_id; @error = error
+      end
+
+      def deconstruct_keys(_) = { id: @id, ref_id: @ref_id, error: @error }
+
+      def self.from_json(d) = new(id: d['id'], ref_id: d['refId'], error: d['error'])
+    end
+
+    class Unknown
+      attr_reader :status
+
+      def initialize(status:)
+        @status = status
+      end
+
+      def deconstruct_keys(_) = { status: @status }
+    end
+
+    module Status
+      def self.from_json(d)
+        case d['status']
+        when 'PENDING'   then Pending.from_json(d)
+        when 'COMPLETED' then Completed.from_json(d)
+        when 'FAILED'    then Failed.from_json(d)
+        when String      then Unknown.new(status: d['status'])
+        else raise IdentisureError.new(0, "Invalid freja status: #{d['status'].inspect}")
+        end
+      end
+    end
+
+    class Endpoint
+      # @api private
+      def initialize(transport)
+        @transport = transport
+      end
+
+      def auth(req)                  = Status.from_json(@transport.post('/v3/freja/auth', req.to_h))
+      def backchannel_auth(req)      = Status.from_json(@transport.post('/v3/freja/backchannel/auth', req.to_h))
+      def sign(req)                  = Status.from_json(@transport.post('/v3/freja/sign', req.to_h))
+      def backchannel_sign(req)      = Status.from_json(@transport.post('/v3/freja/backchannel/sign', req.to_h))
+      def auth_status(id)            = Status.from_json(@transport.get("/v3/freja/auth/#{id}"))
+      def sign_status(id)            = Status.from_json(@transport.get("/v3/freja/sign/#{id}"))
+      def cancel_auth(id)            = @transport.delete("/v3/freja/auth/#{id}")
+      def cancel_sign(id)            = @transport.delete("/v3/freja/sign/#{id}")
+
+      def age_verification(req)
+        Identisure::AgeVerification::Status.from_json(@transport.post('/v3/freja/age-verification', req.to_h))
+      end
+
+      def age_verification_status(id)
+        Identisure::AgeVerification::Status.from_json(@transport.get("/v3/freja/age-verification/#{id}"))
+      end
+
+      def cancel_age_verification(id) = @transport.delete("/v3/freja/age-verification/#{id}")
+
+      def wait_for_auth(id, opts: PollOptions.new) = poll(opts) { auth_status(id) }
+      def wait_for_sign(id, opts: PollOptions.new) = poll(opts) { sign_status(id) }
+
+      def wait_for_age_verification(id, opts: PollOptions.new)
+        poll_age(opts) { age_verification_status(id) }
+      end
+
+      private
+
+      def poll(opts)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + opts.timeout
+        loop do
+          status = yield
+          return status unless status.is_a?(Pending)
+          raise WaitError.new(timeout: true) if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          sleep opts.interval
+        end
+      end
+
+      def poll_age(opts)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + opts.timeout
+        loop do
+          status = yield
+          return status unless status.is_a?(Identisure::AgeVerification::Pending)
+          raise WaitError.new(timeout: true) if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          sleep opts.interval
+        end
+      end
+    end
+  end
+end

data/lib/identisure/ftn.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Identisure
+  module Ftn
+    # --- Request ---
+
+    class AuthRequest
+      attr_reader :redirect_url, :request_phone, :request_email, :request_address, :ref_id
+
+      def initialize(redirect_url: nil, request_phone: nil, request_email: nil,
+                     request_address: nil, ref_id: nil)
+        @redirect_url    = redirect_url
+        @request_phone   = request_phone
+        @request_email   = request_email
+        @request_address = request_address
+        @ref_id          = ref_id
+      end
+
+      def to_h
+        {
+          redirectUrl: @redirect_url,
+          requestPhone: @request_phone,
+          requestEmail: @request_email,
+          requestAddress: @request_address,
+          refId: @ref_id,
+        }.compact
+      end
+    end
+
+    # --- Status variants ---
+
+    class Pending
+      attr_reader :id, :ref_id, :url
+
+      def initialize(id:, url:, ref_id: nil)
+        @id = id; @ref_id = ref_id; @url = url
+      end
+
+      def deconstruct_keys(_) = { id: @id, ref_id: @ref_id, url: @url }
+
+      def self.from_json(d) = new(id: d['id'], ref_id: d['refId'], url: d['url'])
+    end
+
+    class Completed
+      attr_reader :id, :ref_id, :ssn, :name, :given_name, :surname,
+                  :phone, :email, :address, :birth_date, :pid, :bank_id,
+                  :bank_name, :authenticated_at
+
+      def initialize(id:, ssn:, name:, given_name:, surname:,
+                     ref_id: nil, phone: nil, email: nil, address: nil,
+                     birth_date: nil, pid: nil, bank_id: nil, bank_name: nil,
+                     authenticated_at: nil)
+        @id = id; @ref_id = ref_id; @ssn = ssn; @name = name
+        @given_name = given_name; @surname = surname
+        @phone = phone; @email = email; @address = address
+        @birth_date = birth_date; @pid = pid; @bank_id = bank_id
+        @bank_name = bank_name; @authenticated_at = authenticated_at
+      end
+
+      def deconstruct_keys(_)
+        { id: @id, ref_id: @ref_id, ssn: @ssn, name: @name, given_name: @given_name,
+          surname: @surname, phone: @phone, email: @email, address: @address,
+          birth_date: @birth_date, pid: @pid, bank_id: @bank_id,
+          bank_name: @bank_name, authenticated_at: @authenticated_at }
+      end
+
+      def self.from_json(d)
+        new(id: d['id'], ref_id: d['refId'], ssn: d['ssn'], name: d['name'],
+            given_name: d['givenName'], surname: d['surname'],
+            phone: d['phone'], email: d['email'], address: d['address'],
+            birth_date: d['birthDate'], pid: d['pid'], bank_id: d['bankId'],
+            bank_name: d['bankName'], authenticated_at: d['authenticatedAt'])
+      end
+    end
+
+    class Failed
+      attr_reader :id, :ref_id, :error
+
+      def initialize(id:, error:, ref_id: nil)
+        @id = id; @ref_id = ref_id; @error = error
+      end
+
+      def deconstruct_keys(_) = { id: @id, ref_id: @ref_id, error: @error }
+
+      def self.from_json(d) = new(id: d['id'], ref_id: d['refId'], error: d['error'])
+    end
+
+    class Unknown
+      attr_reader :status
+
+      def initialize(status:)
+        @status = status
+      end
+
+      def deconstruct_keys(_) = { status: @status }
+    end
+
+    module Status
+      def self.from_json(d)
+        case d['status']
+        when 'PENDING'   then Pending.from_json(d)
+        when 'COMPLETED' then Completed.from_json(d)
+        when 'FAILED'    then Failed.from_json(d)
+        when String      then Unknown.new(status: d['status'])
+        else raise IdentisureError.new(0, "Invalid ftn status: #{d['status'].inspect}")
+        end
+      end
+    end
+
+    # --- Endpoint ---
+
+    class Endpoint
+      # @api private
+      def initialize(transport)
+        @transport = transport
+      end
+
+      def auth(req)
+        Status.from_json(@transport.post('/v3/ftn/auth', req.to_h))
+      end
+
+      def age_verification(req)
+        Identisure::AgeVerification::Status.from_json(@transport.post('/v3/ftn/age-verification', req.to_h))
+      end
+
+      def auth_status(id) = Status.from_json(@transport.get("/v3/ftn/auth/#{id}"))
+
+      def age_verification_status(id)
+        Identisure::AgeVerification::Status.from_json(@transport.get("/v3/ftn/age-verification/#{id}"))
+      end
+
+      def cancel_auth(id)             = @transport.delete("/v3/ftn/auth/#{id}")
+      def cancel_age_verification(id) = @transport.delete("/v3/ftn/age-verification/#{id}")
+
+      def wait_for_auth(id, opts: PollOptions.new)
+        poll_ftn(opts) { auth_status(id) }
+      end
+
+      def wait_for_age_verification(id, opts: PollOptions.new)
+        poll_age(opts) { age_verification_status(id) }
+      end
+
+      private
+
+      def poll_ftn(opts)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + opts.timeout
+        loop do
+          status = yield
+          return status unless status.is_a?(Pending)
+          raise WaitError.new(timeout: true) if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          sleep opts.interval
+        end
+      end
+
+      def poll_age(opts)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + opts.timeout
+        loop do
+          status = yield
+          return status unless status.is_a?(Identisure::AgeVerification::Pending)
+          raise WaitError.new(timeout: true) if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          sleep opts.interval
+        end
+      end
+    end
+  end
+end

data/lib/identisure/mit_id.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Identisure
+  module MitId
+    class AuthRequest
+      attr_reader :redirect_url, :reference_text, :request_phone, :request_email,
+                  :request_address, :ref_id
+
+      def initialize(redirect_url: nil, reference_text: nil, request_phone: nil,
+                     request_email: nil, request_address: nil, ref_id: nil)
+        @redirect_url = redirect_url; @reference_text = reference_text
+        @request_phone = request_phone; @request_email = request_email
+        @request_address = request_address; @ref_id = ref_id
+      end
+
+      def to_h
+        {
+          redirectUrl: @redirect_url, referenceText: @reference_text,
+          requestPhone: @request_phone, requestEmail: @request_email,
+          requestAddress: @request_address, refId: @ref_id
+        }.compact
+      end
+    end
+
+    class BackchannelAuthRequest
+      attr_reader :ssn, :binding_message, :callback_url, :ref_id
+
+      def initialize(ssn:, binding_message:, callback_url: nil, ref_id: nil)
+        @ssn = ssn; @binding_message = binding_message
+        @callback_url = callback_url; @ref_id = ref_id
+      end
+
+      def to_h
+        {
+          ssn: @ssn, bindingMessage: @binding_message,
+          callbackUrl: @callback_url, refId: @ref_id
+        }.compact
+      end
+    end
+
+    class SignRequest
+      attr_reader :text, :redirect_url, :ref_id
+
+      def initialize(text:, redirect_url: nil, ref_id: nil)
+        @text = text; @redirect_url = redirect_url; @ref_id = ref_id
+      end
+
+      def to_h
+        { text: @text, redirectUrl: @redirect_url, refId: @ref_id }.compact
+      end
+    end
+
+    class SignResult
+      attr_reader :checksum
+
+      def initialize(checksum:)
+        @checksum = checksum
+      end
+
+      def deconstruct_keys(_) = { checksum: @checksum }
+      def self.from_json(d) = new(checksum: d['checksum'])
+    end
+
+    class Pending
+      attr_reader :id, :ref_id, :url, :binding_message
+
+      def initialize(id:, ref_id: nil, url: nil, binding_message: nil)
+        @id = id; @ref_id = ref_id; @url = url; @binding_message = binding_message
+      end
+
+      def deconstruct_keys(_)
+        { id: @id, ref_id: @ref_id, url: @url, binding_message: @binding_message }
+      end
+
+      def self.from_json(d)
+        new(id: d['id'], ref_id: d['refId'], url: d['url'], binding_message: d['bindingMessage'])
+      end
+    end
+
+    class Completed
+      attr_reader :id, :ref_id, :ssn, :name, :given_name, :surname,
+                  :phone, :email, :address, :birth_date, :pid, :bank_id,
+                  :sign_result, :authenticated_at, :signed_at
+
+      def initialize(id:, ssn:, name:, given_name:, surname:, ref_id: nil,
+                     phone: nil, email: nil, address: nil, birth_date: nil,
+                     pid: nil, bank_id: nil, sign_result: nil,
+                     authenticated_at: nil, signed_at: nil)
+        @id = id; @ref_id = ref_id; @ssn = ssn; @name = name
+        @given_name = given_name; @surname = surname; @phone = phone
+        @email = email; @address = address; @birth_date = birth_date
+        @pid = pid; @bank_id = bank_id; @sign_result = sign_result
+        @authenticated_at = authenticated_at; @signed_at = signed_at
+      end
+
+      def deconstruct_keys(_)
+        { id: @id, ref_id: @ref_id, ssn: @ssn, name: @name, given_name: @given_name,
+          surname: @surname, phone: @phone, email: @email, address: @address,
+          birth_date: @birth_date, pid: @pid, bank_id: @bank_id,
+          sign_result: @sign_result, authenticated_at: @authenticated_at,
+          signed_at: @signed_at }
+      end
+
+      def self.from_json(d)
+        new(
+          id: d['id'], ref_id: d['refId'], ssn: d['ssn'], name: d['name'],
+          given_name: d['givenName'], surname: d['surname'], phone: d['phone'],
+          email: d['email'], address: d['address'], birth_date: d['birthDate'],
+          pid: d['pid'], bank_id: d['bankId'],
+          sign_result: d['signResult'] ? SignResult.from_json(d['signResult']) : nil,
+          authenticated_at: d['authenticatedAt'], signed_at: d['signedAt']
+        )
+      end
+    end
+
+    class Failed
+      attr_reader :id, :ref_id, :error
+
+      def initialize(id:, error:, ref_id: nil)
+        @id = id; @ref_id = ref_id; @error = error
+      end
+
+      def deconstruct_keys(_) = { id: @id, ref_id: @ref_id, error: @error }
+      def self.from_json(d) = new(id: d['id'], ref_id: d['refId'], error: d['error'])
+    end
+
+    class Unknown
+      attr_reader :status
+
+      def initialize(status:)
+        @status = status
+      end
+
+      def deconstruct_keys(_) = { status: @status }
+    end
+
+    module Status
+      def self.from_json(d)
+        case d['status']
+        when 'PENDING'   then Pending.from_json(d)
+        when 'COMPLETED' then Completed.from_json(d)
+        when 'FAILED'    then Failed.from_json(d)
+        when String      then Unknown.new(status: d['status'])
+        else raise IdentisureError.new(0, "Invalid mitid status: #{d['status'].inspect}")
+        end
+      end
+    end
+
+    class Endpoint
+      # @api private
+      def initialize(transport)
+        @transport = transport
+      end
+
+      def auth(req)             = Status.from_json(@transport.post('/v3/mitid/auth', req.to_h))
+      def backchannel_auth(req) = Status.from_json(@transport.post('/v3/mitid/backchannel/auth', req.to_h))
+      def sign(req)             = Status.from_json(@transport.post('/v3/mitid/sign', req.to_h))
+      def auth_status(id)       = Status.from_json(@transport.get("/v3/mitid/auth/#{id}"))
+      def sign_status(id)       = Status.from_json(@transport.get("/v3/mitid/sign/#{id}"))
+      def cancel_auth(id)       = @transport.delete("/v3/mitid/auth/#{id}")
+      def cancel_sign(id)       = @transport.delete("/v3/mitid/sign/#{id}")
+
+      def age_verification(req)
+        Identisure::AgeVerification::Status.from_json(@transport.post('/v3/mitid/age-verification', req.to_h))
+      end
+
+      def age_verification_status(id)
+        Identisure::AgeVerification::Status.from_json(@transport.get("/v3/mitid/age-verification/#{id}"))
+      end
+
+      def cancel_age_verification(id) = @transport.delete("/v3/mitid/age-verification/#{id}")
+
+      def wait_for_auth(id, opts: PollOptions.new) = poll(opts) { auth_status(id) }
+      def wait_for_sign(id, opts: PollOptions.new) = poll(opts) { sign_status(id) }
+
+      def wait_for_age_verification(id, opts: PollOptions.new)
+        poll_age(opts) { age_verification_status(id) }
+      end
+
+      private
+
+      def poll(opts)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + opts.timeout
+        loop do
+          status = yield
+          return status unless status.is_a?(Pending)
+          raise WaitError.new(timeout: true) if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          sleep opts.interval
+        end
+      end
+
+      def poll_age(opts)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + opts.timeout
+        loop do
+          status = yield
+          return status unless status.is_a?(Identisure::AgeVerification::Pending)
+          raise WaitError.new(timeout: true) if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          sleep opts.interval
+        end
+      end
+    end
+  end
+end

data/lib/identisure/poll_options.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Identisure
+  class PollOptions
+    attr_reader :interval, :timeout
+
+    def initialize(interval: 2, timeout: 300)
+      @interval = interval
+      @timeout = timeout
+    end
+  end
+end

data/lib/identisure/transport.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'securerandom'
+
+module Identisure
+  # @api private
+  USER_AGENT = "identisure-client-ruby/#{Identisure::VERSION}".freeze
+
+  # @api private
+  class Transport
+    def initialize(connection, base_url, client_id, client_secret, timeout)
+      @conn = connection
+      @timeout = timeout
+      @base_url = base_url.chomp('/')
+      @authorization = "Basic #{["#{client_id}:#{client_secret}"].pack('m0')}"
+    end
+
+    def inspect = "#<#{self.class.name}>"
+
+    def post(path, body)
+      parse(send_request(:post, path, JSON.generate(body), 'Content-Type' => 'application/json'))
+    end
+
+    def get(path)
+      parse(send_request(:get, path))
+    end
+
+    def get_raw(path)
+      send_request(:get, path).body.to_s
+    end
+
+    def delete(path)
+      send_request(:delete, path)
+      nil
+    end
+
+    def post_multipart(path, data, filename, mime_type)
+      boundary = "identisure-#{SecureRandom.hex(16)}"
+      body = multipart_body(boundary, data, filename, mime_type)
+      parse(send_request(:post, path, body, 'Content-Type' => "multipart/form-data; boundary=#{boundary}"))
+    end
+
+    private
+
+    def multipart_body(boundary, data, filename, mime_type)
+      escaped = filename.gsub('"', '%22').gsub("\r", '%0D').gsub("\n", '%0A')
+      body = String.new(encoding: Encoding::BINARY)
+      body << "--#{boundary}\r\n".b
+      body << %(Content-Disposition: form-data; name="file"; filename="#{escaped}"\r\n).b
+      body << "Content-Type: #{mime_type}\r\n\r\n".b
+      body << data.b
+      body << "\r\n--#{boundary}--\r\n".b
+    end
+
+    def send_request(method, path, body = nil, headers = {})
+      headers = headers.merge('Authorization' => @authorization, 'User-Agent' => USER_AGENT)
+      res = @conn.run_request(method, @base_url + path, body, headers) do |req|
+        req.options.timeout = @timeout
+      end
+      raise IdentisureError.new(res.status, error_message(res.body)) unless res.success?
+
+      res
+    rescue Faraday::Error => e
+      raise IdentisureError.new(0, e.message)
+    end
+
+    def parse(res)
+      body = res.body
+      return body if body.is_a?(Hash)
+
+      parsed = JSON.parse(body.to_s)
+      raise IdentisureError.new(res.status, 'Response body is not a JSON object') unless parsed.is_a?(Hash)
+
+      parsed
+    rescue JSON::ParserError => e
+      raise IdentisureError.new(res.status, "Invalid JSON response: #{e.message}")
+    end
+
+    def error_message(body)
+      return body['message'] || body.to_s if body.is_a?(Hash)
+
+      parsed = JSON.parse(body.to_s)
+      parsed.is_a?(Hash) && parsed['message'] ? parsed['message'] : body.to_s
+    rescue JSON::ParserError
+      body.to_s
+    end
+  end
+end