apigratis-sdk-ruby 0.0.1

data/lib/api_brasil/core/transport/net_http_transport.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "timeout"
+require "uri"
+require "json"
+
+module ApiBrasil
+  module Core
+    module Transport
+      # Transporte padrao, sem dependencias: usa apenas `net/http` da stdlib.
+      class NetHttpTransport < Base
+        # Verbos suportados -> classe de requisicao do `net/http`.
+        METHODS = {
+          "GET" => Net::HTTP::Get,
+          "HEAD" => Net::HTTP::Head,
+          "POST" => Net::HTTP::Post,
+          "PUT" => Net::HTTP::Put,
+          "PATCH" => Net::HTTP::Patch,
+          "DELETE" => Net::HTTP::Delete
+        }.freeze
+
+        # Limite de redirecionamentos seguidos automaticamente.
+        MAX_REDIRECTS = 5
+
+        # Erros de conexao tratados como `NetworkError`.
+        NETWORK_ERRORS = [
+          SocketError,
+          IOError,
+          SystemCallError,
+          OpenSSL::SSL::SSLError,
+          Net::HTTPBadResponse,
+          Net::ProtocolError
+        ].freeze
+
+        # @param options [Hash] opcoes extras do `Net::HTTP`
+        #   (ex: `proxy_address`, `proxy_port`, `verify_mode`, `ca_file`)
+        def initialize(options = {})
+          super()
+          @options = options || {}
+        end
+
+        # @param request [Request]
+        # @return [Response]
+        def request(request)
+          perform(request, request.url, MAX_REDIRECTS)
+        end
+
+        private
+
+        def perform(request, url, redirects_left)
+          uri = URI.parse(url)
+          response = execute(request, uri)
+
+          if redirect?(response.code.to_i) && redirects_left.positive?
+            location = response["location"]
+            return perform(request, URI.join(url, location).to_s, redirects_left - 1) if location
+          end
+
+          Response.new(
+            response.code.to_i,
+            normalize_headers(response),
+            Transport.decode_body(request, response.body)
+          )
+        end
+
+        def execute(request, uri)
+          http = build_http(uri, request.timeout_ms)
+          http.request(build_net_request(request, uri))
+        rescue Timeout::Error => e # Net::OpenTimeout, Net::ReadTimeout e Net::WriteTimeout herdam daqui
+          raise Errors::TimeoutError.new(
+            "Tempo limite de #{request.timeout_ms.to_i}ms excedido em #{request.method} #{uri}.",
+            previous: e
+          )
+        rescue *NETWORK_ERRORS => e
+          raise Errors::NetworkError.new(
+            "Falha de rede em #{request.method} #{uri}: #{e.message}",
+            previous: e
+          )
+        end
+
+        def build_http(uri, timeout_ms)
+          # `:ENV` mantem o comportamento padrao de respeitar http_proxy/https_proxy.
+          proxy_address = @options.key?(:proxy_address) ? @options[:proxy_address] : :ENV
+          http = Net::HTTP.new(uri.host, uri.port, proxy_address, @options[:proxy_port],
+                               @options[:proxy_user], @options[:proxy_pass])
+          http.use_ssl = uri.scheme == "https"
+          http.verify_mode = @options[:verify_mode] if @options.key?(:verify_mode)
+          http.ca_file = @options[:ca_file] if @options[:ca_file]
+
+          if timeout_ms.to_i.positive?
+            seconds = timeout_ms.to_f / 1000
+            http.open_timeout = seconds
+            http.read_timeout = seconds
+            http.write_timeout = seconds if http.respond_to?(:write_timeout=)
+          end
+
+          http
+        end
+
+        def build_net_request(request, uri)
+          klass = METHODS[request.method]
+          raise Errors::NetworkError, "Metodo HTTP nao suportado: #{request.method}" if klass.nil?
+
+          path = uri.request_uri
+          net_request = klass.new(path)
+          request.headers.each { |name, value| net_request[name.to_s] = value.to_s }
+          net_request.body = request.body unless request.body.nil?
+
+          net_request
+        end
+
+        def redirect?(status)
+          [301, 302, 303, 307, 308].include?(status)
+        end
+
+        def normalize_headers(response)
+          response.each_header.with_object({}) do |(name, value), acc|
+            acc[name.to_s.downcase] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/api_brasil/core/transport.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "errors"
+
+module ApiBrasil
+  module Core
+    # Camada de transporte HTTP da SDK. A implementacao padrao usa a stdlib
+    # (`NetHttpTransport`), com uso automatico do Faraday quando ele ja esta
+    # carregado no processo (`FaradayTransport`); injete a sua para usar
+    # proxies, outro cliente HTTP, mocks de teste etc.
+    #
+    # Contrato: retorna a resposta para QUALQUER status HTTP; lanca
+    # `NetworkError`/`TimeoutError` apenas quando nao houve resposta.
+    module Transport
+      # Requisicao entregue a camada de transporte - ja com URL absoluta,
+      # headers montados e corpo serializado.
+      class Request
+        # @return [String] verbo HTTP em maiusculas
+        attr_reader :method
+
+        # @return [String] URL absoluta
+        attr_reader :url
+
+        # @return [Hash{String => String}]
+        attr_reader :headers
+
+        # @return [String, nil] corpo ja serializado (JSON)
+        attr_reader :body
+
+        # @return [Integer, nil] timeout em milissegundos
+        attr_reader :timeout_ms
+
+        # @return [String, nil] `json` (padrao), `raw`/`arraybuffer` ou `stream`
+        attr_reader :response_type
+
+        def initialize(method, url, headers: {}, body: nil, timeout_ms: nil, response_type: nil)
+          @method = method.to_s.upcase
+          @url = url
+          @headers = headers || {}
+          @body = body
+          @timeout_ms = timeout_ms
+          @response_type = response_type
+        end
+      end
+
+      # Resposta devolvida pela camada de transporte.
+      class Response
+        # @return [Integer]
+        attr_reader :status
+
+        # @return [Hash{String => String}] headers com nomes em minusculas
+        attr_reader :headers
+
+        # @return [Object] corpo ja decodificado (JSON -> Hash; texto; binario)
+        attr_reader :data
+
+        def initialize(status, headers = {}, data = nil)
+          @status = status
+          @headers = headers || {}
+          @data = data
+        end
+      end
+
+      # Interface do transporte. Implemente `#request` recebendo um
+      # `Transport::Request` e devolvendo um `Transport::Response`.
+      class Base
+        # @param _request [Request]
+        # @return [Response]
+        def request(_request)
+          raise NotImplementedError, "#{self.class}#request precisa ser implementado."
+        end
+      end
+
+      # Tipos de resposta que nao devem ser decodificados como JSON.
+      RAW_RESPONSE_TYPES = %w[raw arraybuffer stream].freeze
+
+      module_function
+
+      # Transporte padrao: Faraday quando ja carregado, senao `net/http`.
+      #
+      # @return [Base]
+      def default
+        return FaradayTransport.new if defined?(::Faraday)
+
+        NetHttpTransport.new
+      end
+
+      # Decodifica o corpo conforme o `response_type` pedido.
+      #
+      # @param request [Request]
+      # @param raw [String, nil]
+      # @return [Object, nil]
+      def decode_body(request, raw)
+        return raw if RAW_RESPONSE_TYPES.include?(request.response_type)
+        return nil if raw.nil? || raw.empty?
+
+        begin
+          JSON.parse(raw)
+        rescue JSON::ParserError
+          raw
+        end
+      end
+    end
+
+    # Aliases com os mesmos nomes usados nas SDKs PHP/Node/Go/Dart.
+    TransportRequest = Transport::Request
+    TransportResponse = Transport::Response
+  end
+end
+
+require_relative "transport/net_http_transport"
+require_relative "transport/faraday_transport"