reacon-sdk 0.1.0.beta.4

data/lib/reacon-sdk/models/verification_stream_error.rb

@@ -0,0 +1,234 @@
+=begin
+#Reacon API
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Reacon
+  class VerificationStreamError < ApiModelBase
+    attr_accessor :code
+
+    attr_accessor :error
+
+    attr_accessor :remaining_credits
+
+    attr_accessor :status
+
+    attr_accessor :updated_at
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'code' => :'code',
+        :'error' => :'error',
+        :'remaining_credits' => :'remainingCredits',
+        :'status' => :'status',
+        :'updated_at' => :'updatedAt'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'code' => :'String',
+        :'error' => :'String',
+        :'remaining_credits' => :'Float',
+        :'status' => :'Integer',
+        :'updated_at' => :'Time'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Reacon::VerificationStreamError` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Reacon::VerificationStreamError`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'code')
+        self.code = attributes[:'code']
+      else
+        self.code = nil
+      end
+
+      if attributes.key?(:'error')
+        self.error = attributes[:'error']
+      else
+        self.error = nil
+      end
+
+      if attributes.key?(:'remaining_credits')
+        self.remaining_credits = attributes[:'remaining_credits']
+      end
+
+      if attributes.key?(:'status')
+        self.status = attributes[:'status']
+      end
+
+      if attributes.key?(:'updated_at')
+        self.updated_at = attributes[:'updated_at']
+      else
+        self.updated_at = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @code.nil?
+        invalid_properties.push('invalid value for "code", code cannot be nil.')
+      end
+
+      if @error.nil?
+        invalid_properties.push('invalid value for "error", error cannot be nil.')
+      end
+
+      if @updated_at.nil?
+        invalid_properties.push('invalid value for "updated_at", updated_at cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @code.nil?
+      return false if @error.nil?
+      return false if @updated_at.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] code Value to be assigned
+    def code=(code)
+      if code.nil?
+        fail ArgumentError, 'code cannot be nil'
+      end
+
+      @code = code
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] error Value to be assigned
+    def error=(error)
+      if error.nil?
+        fail ArgumentError, 'error cannot be nil'
+      end
+
+      @error = error
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] updated_at Value to be assigned
+    def updated_at=(updated_at)
+      if updated_at.nil?
+        fail ArgumentError, 'updated_at cannot be nil'
+      end
+
+      @updated_at = updated_at
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          code == o.code &&
+          error == o.error &&
+          remaining_credits == o.remaining_credits &&
+          status == o.status &&
+          updated_at == o.updated_at
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [code, error, remaining_credits, status, updated_at].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/reacon-sdk/verification_stream.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+# Copyright Reacon contributors. Licensed under Apache-2.0.
+require 'net/http'
+require 'json'
+require 'event_stream_parser'
+
+module Reacon
+  class StreamProtocolError < StandardError; end
+  class StreamTransportError < StandardError; end
+  class StreamCancelledError < StandardError; end
+  class StreamTimeoutError < StandardError
+    attr_reader :phase
+    def initialize(phase)
+      @phase = phase
+      super("Reacon #{phase} timeout")
+    end
+  end
+  class StreamAPIError < StandardError
+    attr_reader :status, :headers, :body, :event
+    def initialize(response, body, event = nil)
+      @status, @headers, @body, @event = response.code.to_i, response.to_hash, body, event
+      super(event ? "Reacon stream failed: #{event.code}" : "Reacon returned HTTP #{@status}")
+    end
+    def request_id = headers['x-request-id']&.first
+  end
+  VerificationEvent = Struct.new(:kind, :data, :raw, keyword_init: true)
+
+  # Credentials are per instance. Each active stream owns its Net::HTTP connection.
+  class VerificationStreamClient
+    def initialize(api_key:, base_url: 'https://api.reacon.io', ca_file: nil)
+      raise ArgumentError, 'api_key is required' if api_key.to_s.strip.empty?
+      @key, @base_url, @ca_file = api_key, base_url.delete_suffix('/'), ca_file
+    end
+    # Creating a stream does no I/O. Use #each with a block; #close cancels from another thread.
+    def stream_verification(email, only_if_free: nil, cache_max_age: nil, idle_timeout: 30, total_timeout: 300)
+      raise ArgumentError, 'Email and positive timeouts are required' if email.to_s.empty? || idle_timeout <= 0 || total_timeout <= 0
+      raise ArgumentError, 'Invalid only_if_free' unless [nil, true, false, 'true', 'false'].include?(only_if_free)
+      raise ArgumentError, 'Invalid cache_max_age' unless [nil, 'live', '1d', '1w', '1m'].include?(cache_max_age)
+      uri = URI("#{@base_url}/v1/verify")
+      query = { email: email }; query[:onlyIfFree] = only_if_free unless only_if_free.nil?; query[:cacheMaxAge] = cache_max_age if cache_max_age
+      uri.query = URI.encode_www_form(query)
+      VerificationStream.new(uri, @key, @ca_file, idle_timeout, total_timeout)
+    end
+  end
+
+  class VerificationStream
+    class Finished < StandardError; end
+    private_constant :Finished
+    def initialize(uri, key, ca_file, idle_timeout, total_timeout)
+      @uri, @key, @ca_file, @idle_timeout, @total_timeout = uri, key, ca_file, idle_timeout, total_timeout
+      @mutex, @condition = Mutex.new, ConditionVariable.new
+      @reason = nil; @finished = false; @started = false
+    end
+    def close
+      abort_with(StreamCancelledError.new('Verification stream cancelled'))
+      nil
+    end
+    # Block iteration guarantees cleanup after `break` and exceptions. External Enumerator#next
+    # is deliberately not offered, because abandoning its suspended Fiber leaks the response.
+    def each
+      raise ArgumentError, 'A block is required; use stream.each { |event| ... }' unless block_given?
+      @mutex.synchronize do
+        raise @reason if @reason
+        raise ArgumentError, 'Stream has already been consumed' if @started
+        @started = true
+      end
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      http.use_ssl = @uri.scheme == 'https'; http.ca_file = @ca_file if @ca_file
+      http.max_retries = 0
+      http.open_timeout = [@idle_timeout, @total_timeout].min
+      http.read_timeout = @idle_timeout
+      @mutex.synchronize { @http = http }
+      timer = Thread.new do
+        @mutex.synchronize { @condition.wait(@mutex, @total_timeout) unless @finished || @reason }
+        abort_with(StreamTimeoutError.new('total')) unless @mutex.synchronize { @finished || @reason }
+      end
+      begin
+        raise @reason if @reason
+        http.start do
+          request = Net::HTTP::Get.new(@uri.request_uri, 'X-API-Key' => @key, 'Accept' => 'text/event-stream')
+          http.request(request) do |response|
+            unless response.code.to_i.between?(200, 299)
+              text = +''.b
+              response.read_body { |chunk| text << chunk.byteslice(0, 65_536 - text.bytesize); break if text.bytesize >= 65_536 }
+              begin; body = JSON.parse(text); rescue JSON::ParserError; body = text; end
+              raise StreamAPIError.new(response, body)
+            end
+            raise StreamProtocolError, 'Expected a text/event-stream response body' unless response.content_type == 'text/event-stream'
+            parser = EventStreamParser::Parser.new
+            prefix = +''.b
+            ready = false
+            begin
+              response.read_body do |chunk|
+                raise @reason if @reason
+                # Keep framing byte-oriented until the complete JSON event is available.
+                chunk = chunk.b
+                unless ready
+                  prefix << chunk
+                  next if prefix.bytesize < 3
+                  chunk = prefix.delete_prefix("\xEF\xBB\xBF".b); ready = true
+                end
+                parser.feed(chunk) do |_type, data, _id, _retry|
+                  event = decode(data, response)
+                  if event.kind == :final
+                    finish
+                    http.finish if http.started?
+                    yield event
+                    # Unwind the Net::HTTP response scope before its normal body-drain
+                    # step. The terminal event may arrive on an indefinitely open body.
+                    raise Finished
+                  end
+                  yield event
+                end
+              end
+              raise StreamProtocolError, 'Verification stream ended before a terminal event'
+            end
+          end
+        end
+      rescue Finished
+        nil
+      rescue Net::OpenTimeout, Net::ReadTimeout
+        raise(@reason || StreamTimeoutError.new('idle'))
+      rescue IOError, EOFError, SystemCallError, OpenSSL::SSL::SSLError
+        raise(@reason || StreamTransportError.new('Reacon stream transport failure'))
+      ensure
+        finish
+        http.finish if http.started?
+        timer.join
+      end
+      nil
+    end
+
+    private
+
+    def finish
+      @mutex.synchronize { @finished = true; @condition.broadcast }
+    end
+    def abort_with(reason)
+      http = @mutex.synchronize do
+        return if @finished || @reason
+        @reason = reason; @condition.broadcast; @http
+      end
+      http.finish if http&.started?
+    rescue IOError, SystemCallError
+      # Closing races with normal cleanup; the retained reason wins the read error.
+    end
+    def decode(data, response)
+      raw = JSON.parse(data.dup.force_encoding(Encoding::UTF_8))
+      raise StreamProtocolError, 'Expected an SSE JSON object' unless raw.is_a?(Hash)
+      # Generated Ruby model conversion is permissive about absent required fields;
+      # validate required wire fields before converting, retaining all unknown fields in raw.
+      if raw.key?('error')
+        require_fields(raw, 'error' => String, 'code' => String, 'updatedAt' => String)
+        raise StreamAPIError.new(response, raw, VerificationStreamError.build_from_hash(raw))
+      elsif raw.key?('result')
+        require_fields(raw, 'result' => Hash, 'updatedAt' => String)
+        require_fields(raw['result'], 'status' => String, 'catchAll' => [TrueClass, FalseClass], 'disposable' => [TrueClass, FalseClass])
+        VerificationEvent.new(kind: :final, data: VerificationFinal.build_from_hash(raw), raw: raw)
+      elsif raw.key?('stage')
+        require_fields(raw, 'stage' => String, 'updatedAt' => String)
+        VerificationEvent.new(kind: :stage, data: VerificationStage.build_from_hash(raw), raw: raw)
+      elsif raw.key?('state')
+        require_fields(raw, 'state' => String, 'updatedAt' => String)
+        VerificationEvent.new(kind: :progress, data: VerificationProgress.build_from_hash(raw), raw: raw)
+      else
+        VerificationEvent.new(kind: :unknown, raw: raw)
+      end
+    rescue JSON::ParserError, ArgumentError, TypeError
+      raise StreamProtocolError, 'Malformed verification event'
+    end
+    def require_fields(raw, fields)
+      fields.each do |name, types|
+        raise StreamProtocolError, "Invalid verification field: #{name}" unless Array(types).any? { |type| raw[name].is_a?(type) }
+      end
+    end
+  end
+end

data/lib/reacon-sdk/version.rb

@@ -0,0 +1,15 @@
+=begin
+#Reacon API
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+module Reacon
+  VERSION = '0.1.0.beta.4'
+end