fastpixapi 1.0.0 → 1.1.0

data/lib/fastpix_api_sdk/utils/request_bodies.rb

@@ -1,60 +0,0 @@
-
-# typed: true
-# frozen_string_literal: true
-
-require 'cgi'
-require 'date'
-require 'base64'
-require 'sorbet-runtime'
-
-module FastpixApiSDK
-  module Utils
-    extend T::Sig
-
-    SERIALIZATION_METHOD_TO_CONTENT_TYPE = {
-        'json': 'application/json',
-        'form': 'application/x-www-form-urlencoded',
-        'multipart': 'multipart/form-data',
-        'raw': 'application/octet-stream',
-        'string': 'text/plain'
-      }.freeze
-  
-    sig do
-      params(request: Object, nullable: T::Boolean, optional: T::Boolean, request_field_name: Symbol, serialization_method: Symbol)
-        .returns([String, Object, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]])])
-    end
-    def self.serialize_request_body(request, nullable, optional, request_field_name, serialization_method)
-      return ['', nil, nil] if request.nil? && !nullable && optional
-
-      return serialize_content_type(SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method], request) if !request.respond_to?(:fields) || !request.respond_to?(request_field_name)
-
-      request_val = request.send(request_field_name)
-
-      request_metadata = T.let(nil, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]]))
-      T.unsafe(request).fields.each do |f|
-        if f.name == request_field_name
-          request_metadata = f.metadata[:request]
-          break
-        end
-      end
-      raise StandardError, 'invalid request type' if request_metadata.nil?
-
-      serialize_content_type(
-        request_metadata.fetch(:media_type, 'application/octet-stream'), request_val
-      )
-    end
-
-    sig do
-      params(media_type: String, request: Object)
-        .returns([String, Object, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]])])
-    end
-    def self.serialize_content_type(media_type, request)
-      return media_type, ::Crystalline.to_json(request), nil if media_type.match('(application|text)\/.*?\+*json.*')
-      return serialize_multipart_form(media_type, request) if media_type.match('multipart\/.*')
-      return media_type, serialize_form_data(request), nil if media_type.match('application\/x-www-form-urlencoded.*')
-      return media_type, request, nil if request.is_a?(String) || request.is_a?(Array)
-
-      raise StandardError, "invalid request body type #{request.class} for mediaType #{media_type}"
-    end
-  end
-end

data/lib/fastpix_api_sdk/utils/retries.rb

@@ -1,99 +0,0 @@
-
-# typed: true
-# frozen_string_literal: true
-
-require 'faraday/retry'
-require 'sorbet-runtime'
-
-module FastpixApiSDK
-  module Utils
-    class BackoffStrategy
-      extend T::Sig
-
-      sig { returns(T.nilable(::Float)) }
-      attr_accessor :exponent
-
-      sig { returns(T.nilable(::Integer)) }
-      attr_accessor :initial_interval
-
-      sig { returns(T.nilable(::Integer)) }
-      attr_accessor :max_elapsed_time
-
-      sig { returns(T.nilable(::Integer)) }
-      attr_accessor :max_interval
-
-      sig do
-        params(
-          exponent: T.nilable(::Float),
-          initial_interval: T.nilable(::Integer),
-          max_elapsed_time: T.nilable(::Integer),
-          max_interval: T.nilable(::Integer)
-        ).void
-      end
-      def initialize(exponent: nil, initial_interval: nil, max_elapsed_time: nil, max_interval: nil)
-        @exponent = T.let(exponent, T.nilable(::Float))
-        @initial_interval = T.let(initial_interval, T.nilable(::Integer))
-        @max_elapsed_time = T.let(max_elapsed_time, T.nilable(::Integer))
-        @max_interval = T.let(max_interval, T.nilable(::Integer))
-      end
-    end
-
-    class RetryConfig
-      extend T::Sig
-
-      sig { returns(T.nilable(BackoffStrategy)) }
-      attr_accessor :backoff
-
-      sig { returns(T.nilable(T::Boolean)) }
-      attr_accessor :retry_connection_errors
-
-      sig { returns(T.nilable(::String)) }
-      attr_accessor :strategy
-
-      sig do
-        params(
-          backoff: T.nilable(BackoffStrategy),
-          retry_connection_errors: T.nilable(T::Boolean),
-          strategy: T.nilable(::String)
-        ).void
-      end
-      def initialize(backoff: nil, retry_connection_errors: nil, strategy: nil)
-        @backoff = T.let(backoff, T.nilable(BackoffStrategy))
-        @retry_connection_errors = T.let(retry_connection_errors, T.nilable(T::Boolean))
-        @strategy = T.let(strategy, T.nilable(::String))
-      end
-
-      sig { params(initial_time: ::Time).returns(::Hash) }
-      def to_faraday_retry_options(initial_time:)
-        retry_options = {
-          # must overwrite default max of 2 retries and it must be positive
-          max: 1_000_000_000,
-          # ensure all HTTP methods are retried, especially via retry_if
-          methods: [],
-        }
-
-        if @retry_connection_errors
-          retry_options[:exceptions] = Faraday::Retry::Middleware::DEFAULT_EXCEPTIONS + [Faraday::ConnectionFailed]
-        end
-
-        if @strategy == 'backoff' && @backoff
-          retry_options[:backoff_factor] = @backoff.exponent unless @backoff.exponent.nil?
-          retry_options[:interval] = (@backoff.initial_interval.to_f / 1000) unless @backoff.initial_interval.nil?
-          retry_options[:max_interval] = @backoff.max_interval unless @backoff.max_interval.nil?
-
-          unless @backoff.max_elapsed_time.nil?
-            stop_time = initial_time + (@backoff.max_elapsed_time.to_f / 1000)
-            retry_options[:retry_if] = ->(_env, _exc) { Time.now < stop_time }
-          end
-        end
-
-        retry_options
-      end
-
-      sig { returns(::Hash) }
-      def to_h
-        to_faraday_retry_options(initial_time: Time.now)
-      end
-    end
-  end
-end

data/lib/fastpix_api_sdk/utils/security.rb

@@ -1,129 +0,0 @@
-
-# typed: true
-# frozen_string_literal: true
-
-require 'cgi'
-require 'date'
-require 'base64'
-require 'sorbet-runtime'
-
-module FastpixApiSDK
-  module Utils
-    extend T::Sig
-
-    sig { params(req: Faraday::Request, security: Object).void }
-    def self.configure_request_security(req, security)
-      return if security.nil?
-      T.unsafe(security).fields.each do |sec_field|
-        value = security.send(sec_field.name)
-        next if value.nil?
-
-        metadata = sec_field.metadata[:security]
-        next if metadata.nil?
-
-        _parse_security_option(req, value) if metadata[:option]
-
-        if metadata[:scheme]
-          # Special case for basic auth which could be a flattened struct
-          if metadata[:sub_type] == 'basic' && !value.respond_to?(:fields)
-            _parse_security_scheme(req, metadata, security)
-          else
-            _parse_security_scheme(req, metadata, value)
-          end
-        end
-      end
-    end
-
-    sig { params(req: Faraday::Request, option: Object).void }
-    def self._parse_security_option(req, option)
-      T.unsafe(option).fields.each do |opt_field|
-        metadata = opt_field.metadata[:security]
-        next if metadata.nil? || !metadata.include?(:scheme)
-
-        _parse_security_scheme(req, metadata, option.send(opt_field.name))
-      end
-    end
-
-    sig { params(req: Faraday::Request, scheme_metadata: T::Hash[Symbol, String], scheme: Object).void }
-    def self._parse_security_scheme(req, scheme_metadata, scheme)
-      scheme_type = scheme_metadata[:type]
-      sub_type = scheme_metadata[:sub_type]
-
-      if scheme.respond_to? :fields
-        if scheme_type == 'http' && sub_type == 'basic'
-          _parse_basic_auth_scheme(req, scheme)
-          return
-        end
-
-        T.unsafe(scheme).fields.each do |field|
-          metadata = field.metadata[:security]
-          next if metadata.nil? || metadata[:field_name].nil?
-
-          value = scheme.send(field.name)
-          _parse_security_scheme_value(req, scheme_metadata, metadata, T.cast(value, String))
-        end
-      else
-        _parse_security_scheme_value(req, scheme_metadata, scheme_metadata, T.cast(scheme, String))
-      end
-    end
-
-    sig do
-      params(req: Faraday::Request, scheme_metadata: T::Hash[Symbol, String],
-             security_metadata: T::Hash[Symbol, String], value: String).void
-    end
-    def self._parse_security_scheme_value(req, scheme_metadata, security_metadata, value)
-      scheme_type = scheme_metadata[:type]
-      sub_type = scheme_metadata[:sub_type]
-
-      header_name = security_metadata[:field_name]
-
-      case scheme_type
-      when 'apiKey'
-        case sub_type
-        when 'header'
-          req.headers[header_name] = value
-        when 'query'
-          req.params[header_name] = value
-        when 'cookie'
-          req.headers['Cookie'][header_name] = value
-        else
-          raise StandardError, 'not supported'
-        end
-      when 'openIdConnect'
-        req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
-      when 'oauth2'
-        req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
-      when 'http'
-        if sub_type == 'bearer'
-          req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
-        elsif sub_type != 'custom'
-          raise StandardError, 'not supported'
-        end
-      else
-        raise StandardError, 'not supported'
-      end
-    end
-
-    sig { params(req: Faraday::Request, scheme: Object).void }
-    def self._parse_basic_auth_scheme(req, scheme)
-      username = T.let('', String)
-      password = T.let('', String)
-
-      T.unsafe(scheme).fields.each do |scheme_field|
-        metadata = scheme_field.metadata[:security]
-        next if metadata.nil? || !metadata.include?(:field_name)
-
-        field_name = metadata[:field_name]
-        value = scheme.send(scheme_field.name)
-
-        username = T.let(value, String) if field_name == 'username'
-        password = T.let(value, String) if field_name == 'password'
-      end
-
-      data = "#{username}:#{password}".encode
-      # Use strict_encode, because encode adds newlines after 60 chars
-      # https://docs.ruby-lang.org/en/3.0/Base64.html#method-i-encode64
-      req.headers['Authorization'] = "Basic #{Base64.strict_encode64(data)}"
-    end
-  end
-end

data/lib/fastpix_api_sdk/utils/url.rb

@@ -1,99 +0,0 @@
-
-# typed: true
-# frozen_string_literal: true
-
-require 'faraday/retry'
-require 'sorbet-runtime'
-
-module FastpixApiSDK
-  module Utils
-    sig { params(clazz: Object, server_url: String, path: String, path_params: Object, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(String) }
-    def self.generate_url(clazz, server_url, path, path_params, gbls = nil)
-      T.unsafe(clazz).fields.each do |f|
-        param_metadata = f.metadata[:path_param]
-        next if param_metadata.nil?
-
-        if param_metadata.fetch(:style, 'simple') == 'simple'
-          param = path_params.send(f.name) if !path_params.nil?
-          param = _populate_from_globals(f.name, param, 'pathParam', gbls)
-        end
-
-        f_name = param_metadata.fetch(:field_name, f.name)
-        serialization = param_metadata.fetch(:serialization, '')
-        if serialization != ''
-          serialized_params = _get_serialized_params(param_metadata, f_name, param)
-          serialized_params.each do |k, v|
-            path = path.sub("{#{k}}", v.join(', '))
-          end
-        else
-          if param.is_a? Array
-            pp_vals = []
-            param.each do |pp_val|
-              pp_vals.append(pp_val.to_s)
-            end
-            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
-          elsif param.is_a? Hash
-            pp_vals = []
-            param.each do |pp_key, pp_val|
-              value = val_to_string(pp_val)
-
-              if param_metadata.fetch(:explode, false)
-                pp_vals.append("#{pp_key}=#{value}")
-              else
-                pp_vals.append("#{pp_key},#{value}")
-              end
-            end
-            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
-          elsif param.class.include?(::Crystalline::MetadataFields)
-            pp_vals = []
-            attrs = T.unsafe(param).fields.filter { |field| field.name && param.respond_to?(field.name.to_sym) }.map(&:name)
-            attrs.each do |attr|
-              field = T.unsafe(param).field(attr)
-
-              param_value_metadata = field.metadata[:path_param]
-
-              next if param_value_metadata.nil?
-
-              parm_name = param_value_metadata.fetch(:field_name, f.name)
-
-              param_field_val = param.send(attr)
-
-              if param_field_val.class.respond_to?(:enums)
-                param_field_val = param_field_val.serialize
-              elsif param_field_val.is_a? DateTime
-                param_field_val = param_field_val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
-              end
-              if !field.nil? && ::Crystalline::Utils.nilable?(field.type) && param_field_val.nil?
-                next
-              elsif param_metadata.fetch(:explode, false)
-                pp_vals.append("#{parm_name}=#{param_field_val}")
-              else
-                pp_vals.append("#{parm_name},#{param_field_val}")
-              end
-            end
-            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
-          else
-            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", val_to_string(param))
-          end
-        end
-      end
-
-      server_url.delete_suffix('/') + path
-    end
-
-    sig { params(url_with_params: String, params: T::Hash[Symbol, T.any(String, T::Enum)]).returns(String) }
-    def self.template_url(url_with_params, params)
-      params.each do |key, value|
-        if value.class.respond_to? :enums
-          val_str = T.cast(value, T::Enum).serialize
-        else
-          val_str = value
-        end
-        url_with_params = url_with_params.gsub("{#{key}}", val_str)
-      end
-
-      url_with_params
-    end
-
-  end
-end

data/lib/fastpix_api_sdk/utils/utils.rb

@@ -1,188 +0,0 @@
-
-# typed: true
-# frozen_string_literal: true
-
-require 'cgi'
-require 'date'
-require 'base64'
-require 'stringio'
-require 'json'
-require 'uri'
-require 'sorbet-runtime'
-
-module FastpixApiSDK
-  module Utils
-    include Kernel
-    extend T::Sig
-
-    sig { params(val: Object).returns(String) }
-    def self.val_to_string(val)
-      if val.class.respond_to?(:enums)
-        T.unsafe(val).serialize.to_s
-      elsif val.is_a? DateTime
-        val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
-      else
-        val.to_s
-
-      end
-    end
-
-    sig do
-      params(metadata: T::Hash[Symbol, String], field_name: String, obj: Object)
-        .returns(T::Hash[Symbol, T::Array[String]])
-    end
-    def self._get_serialized_params(metadata, field_name, obj)
-      params = {}
-
-      serialization = metadata.fetch(:serialization, '')
-      params[metadata.fetch(:field_name, field_name)] = [obj.to_json] if serialization == 'json'
-
-      params
-    end
-
-
-    sig { params(status: Integer).returns(T::Boolean) }
-    def self.error_status?(status)
-      status_major = status / 100
-      return true if status_major == 4
-      return true if status_major == 5
-
-      false
-    end
-
-    sig { params(content_type: String, pattern: String).returns(T::Boolean) }
-    def self.match_content_type(content_type, pattern)
-      return true if content_type == pattern || ['*', '*/*'].include?(pattern)
-
-      pieces = content_type.split(';')
-      pieces.each do |piece|
-        return true if pattern == piece.strip
-      end
-
-      false
-    end
-
-    sig { params(status_code: Integer, status_codes: T::Array[String]).returns(T::Boolean) }
-    def self.match_status_code(status_code, status_codes)
-      return true if status_codes.include? 'default'
-      status_code = status_code.to_s
-      status_codes.each do |code|
-        return true if code == status_code
-        return true if code.downcase.end_with?('xx') && status_code[0] == code[0]
-      end
-      false
-    end
-
-    sig { params(optional: T::Boolean).returns(T.proc.params(s: String).returns(T.nilable(DateTime))) }
-    def self.datetime_from_iso_format(optional)
-      Kernel.lambda do |s|
-        return nil if optional && s.nil?
-
-        return DateTime.strptime(s, '%Y-%m-%dT%H:%M:%S.%NZ')
-      end
-    end
-
-    sig { params(optional: T::Boolean).returns(T.proc.params(s: String).returns(T.nilable(Date))) }
-    def self.date_from_iso_format(optional)
-      Kernel.lambda do |s|
-        return nil if optional && s.nil?
-
-        return Date.iso8601(s)
-      end
-    end
-
-    sig do
-      params(enum_type: T.class_of(T::Enum), optional: T::Boolean)
-        .returns(T.nilable(T.proc.params(s: String).returns(T.nilable(T::Enum))))
-    end
-    def self.enum_from_string(enum_type, optional)
-      Kernel.lambda do |s|
-        return nil if optional && s.nil?
-
-        return enum_type.deserialize(s)
-      end
-    end
-
-    sig { params(name: String).returns(T.proc.returns(String)) }
-    def self.field_name(name)
-      T.let(proc { name }, T.proc.returns(String))
-    end
-
-
-    sig { params(field: ::Crystalline::MetadataFields::Field, data_class: Object).returns(Object) }
-    def self.parse_field(field, data_class)
-      field_metadata = field.metadata[:metadata_string]
-      return nil if field_metadata.nil?
-
-      field_value = data_class.send(field.name)
-      return nil if field_value.nil?
-
-      field_value
-    end
-
-    sig do
-      params(form: T::Array[T::Array[T.any(String, T::Array[T.nilable(String)])]])
-        .returns(T::Hash[Symbol, Object])
-    end
-    def self.encode_form(form)
-      payload = {}
-      form.each do |field_name, field|
-        field = T.must(field)
-        if field.length == 2
-          if field[0].nil?
-            # Handle multiple values for the same field name (arrays)
-            if payload.key?(field_name)
-              # Convert to array if not already
-              unless payload[field_name].is_a?(Array)
-                payload[field_name] = [payload[field_name]]
-              end
-              payload[field_name] << field[1]
-            else
-              payload[field_name] = field[1]
-            end
-          else
-            # Handle file uploads
-            file_part = Faraday::Multipart::FilePart.new(
-              StringIO.new(T.must(field[1])),
-              'application/octet-stream',
-              field[0]
-            )
-            
-            # Handle multiple files for the same field name (arrays)
-            if payload.key?(field_name)
-              unless payload[field_name].is_a?(Array)
-                payload[field_name] = [payload[field_name]]
-              end
-              payload[field_name] << file_part
-            else
-              payload[field_name] = file_part
-            end
-          end
-        elsif field.length == 3
-          param_part = Faraday::Multipart::ParamPart.new(field[1].to_json, field[2])
-          
-          # Handle multiple values for the same field name (arrays)
-          if payload.key?(field_name)
-            unless payload[field_name].is_a?(Array)
-              payload[field_name] = [payload[field_name]]
-            end
-            payload[field_name] << param_part
-          else
-            payload[field_name] = param_part
-          end
-        end
-      end
-      payload
-    end
-
-    sig { params(param_name: Symbol, value: Object, param_type: String, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(Object) }
-    def self._populate_from_globals(param_name, value, param_type, gbls)
-      if value.nil? && !gbls.nil?
-        global_value = gbls.dig(:parameters, param_type.to_sym, param_name.to_sym)
-        value = global_value if !global_value.nil?
-      end
-      value
-    end
-
-  end
-end