telegem 1.0.6 → 2.0.0

data/lib/api/client.rb

@@ -1,20 +1,20 @@
-# lib/api/client.rb - CORRECTED VERSION
+# lib/api/client.rb - V2.0.0 (ASYNC-FIRST, NON-BLOCKING)
 require 'httpx'
+require 'json'
 
 module Telegem
   module API
     class Client
       BASE_URL = 'https://api.telegram.org'
       
-      attr_reader :token, :logger, :http
+      attr_reader :token, :logger, :http, :connection_pool
 
-      def initialize(token, logger: nil, timeout: 30)
+      def initialize(token, logger: nil, timeout: 30, pool_size: 10)
         @token = token
         @logger = logger || Logger.new($stdout)
         
-        # HTTPX with persistent connections and proper async support
+        # HTTPX with proper async configuration
         @http = HTTPX.plugin(:persistent)
-                     .plugin(:retries, max_retries: 3)
                      .with(
                        timeout: { 
                          connect_timeout: 10,
@@ -24,39 +24,69 @@ module Telegem
                        },
                        headers: {
                          'Content-Type' => 'application/json',
-                         'User-Agent' => "Telegem/#{Telegem::VERSION}"
-                       }
+                         'User-Agent' => "Telegem/#{Telegem::VERSION} (Ruby #{RUBY_VERSION}; #{RUBY_PLATFORM})"
+                       },
+                       max_requests: pool_size  # Connection pool
                      )
+        
+        # Add retry plugin if available
+        if HTTPX.plugins.key?(:retries)
+          @http = @http.plugin(:retries, max_retries: 3, retry_on: [500, 502, 503, 504])
+        end
+        
+        # Ensure proper cleanup
+        ObjectSpace.define_finalizer(self, proc { close })
       end
 
-      # Main API call - returns HTTPX request (promise-like object)
+      # PRIMARY API: Async call - returns HTTPX request (promise-like)
       def call(method, params = {})
         url = "#{BASE_URL}/bot#{@token}/#{method}"
         
-        @logger.debug("API Call: #{method}") if @logger
+        @logger.debug("🚀 Async API: #{method}") if @logger
         
-        # Return the async request object directly
+        # Pure async - returns immediately
         @http.post(url, json: params.compact)
-             .then(&method(:handle_response))
-             .on_error(&method(:handle_error))
+             .then(&method(:handle_response_async))
+             .on_error(&method(:handle_error_async))
       end
 
-      # File upload method
-      def upload(method, params)
-        url = "#{BASE_URL}/bot#{@token}/#{method}"
+      # SYNC WRAPPER: For when you absolutely need blocking
+      def call!(method, params = {}, timeout: nil)
+        timeout ||= @http.options.timeout[:read_timeout]
         
-        # Convert params to multipart form data
-        form = params.map do |key, value|
-          if file_object?(value)
-            [key.to_s, HTTPX::FormData::File.new(value)]
-          else
-            [key.to_s, value.to_s]
+        # Start async request
+        request = call(method, params)
+        
+        # Wait with timeout
+        begin
+          wait_result = request.wait(timeout)
+          
+          if request.error
+            # Error already logged by handle_error_async
+            raise APIError, request.error.message
+          elsif !wait_result
+            raise NetworkError, "Request timeout after #{timeout}s"
           end
+          
+          # Return the actual result (not the request object)
+          request.instance_variable_get(:@result) || request.response
+        rescue Timeout::Error
+          raise NetworkError, "Request timeout after #{timeout}s"
         end
+      end
+
+      # File upload - also async
+      def upload(method, params)
+        url = "#{BASE_URL}/bot#{@token}/#{method}"
+        
+        # Build multipart form
+        form = build_multipart_form(params)
+        
+        @logger.debug("📤 Async Upload: #{method}") if @logger
         
         @http.post(url, form: form)
-             .then(&method(:handle_response))
-             .on_error(&method(:handle_error))
+             .then(&method(:handle_response_async))
+             .on_error(&method(:handle_error_async))
       end
 
       # Convenience method for getUpdates with proper async handling
@@ -73,55 +103,90 @@ module Telegem
         @http.close
       end
 
-      # Synchronous version (for convenience in non-async contexts)
-      def call!(method, params = {})
-        request = call(method, params)
-        request.wait  # Wait for completion
-        handle_response(request)
-      rescue => e
-        handle_error(e, request)
-      end
-
       private
 
-      def handle_response(response)
+      # Async response handler - stores result on request object
+      def handle_response_async(response)
         response.raise_for_status unless response.status == 200
         
-        json = response.json
-        unless json
-          raise APIError, "Empty or invalid JSON response"
-        end
-        
-        if json['ok']
-          json['result']
+        case response.status
+        when 429  # Rate limit
+          retry_after = response.headers['retry-after']&.to_i || 1
+          raise RateLimitError.new("Rate limited", retry_after)
+        when 200
+          begin
+            json = response.json
+          rescue JSON::ParserError => e
+            raise APIError, "Invalid JSON: #{e.message}"
+          end
+          
+          unless json
+            raise APIError, "Empty response"
+          end
+          
+          if json['ok']
+            # Store result on request for sync access
+            response.request.instance_variable_set(:@result, json['result'])
+            json['result']
+          else
+            raise APIError.new(json['description'], json['error_code'])
+          end
         else
-          raise APIError.new(json['description'], json['error_code'])
+          response.raise_for_status
         end
       end
 
-      def handle_error(error, request = nil)
+      # Async error handler
+      def handle_error_async(error)
         case error
         when HTTPX::TimeoutError
-          @logger.error("Telegram API timeout: #{error.message}") if @logger
-          raise NetworkError, "Request timeout: #{error.message}"
+          @logger.error("⏰ Timeout: #{error.message}") if @logger
+          raise NetworkError, "Timeout: #{error.message}"
         when HTTPX::ConnectionError
-          @logger.error("Connection error: #{error.message}") if @logger
+          @logger.error("🔌 Connection: #{error.message}") if @logger
           raise NetworkError, "Connection failed: #{error.message}"
         when HTTPX::HTTPError
-          @logger.error("HTTP error #{error.response.status}: #{error.message}") if @logger
+          @logger.error("🌐 HTTP #{error.response.status}: #{error.message}") if @logger
           raise APIError, "HTTP #{error.response.status}: #{error.message}"
+        when RateLimitError
+          @logger.error("🚦 Rate limit: retry after #{error.retry_after}s") if @logger
+          raise error  # Re-raise for user handling
         else
-          @logger.error("Unexpected error: #{error.class}: #{error.message}") if @logger
+          @logger.error("💥 Unexpected: #{error.class}: #{error.message}") if @logger
           raise APIError, error.message
         end
       end
 
+      def build_multipart_form(params)
+        params.map do |key, value|
+          if file_object?(value)
+            [key.to_s, HTTPX::FormData::File.new(value)]
+          else
+            [key.to_s, value.to_s]
+          end
+        end
+      end
+
       def file_object?(obj)
-        obj.is_a?(File) || obj.is_a?(StringIO) || obj.is_a?(Tempfile) ||
-          (obj.is_a?(String) && File.exist?(obj))
+        case obj
+        when File, StringIO, Tempfile
+          true
+        when Pathname
+          obj.exist? && obj.readable?
+        when String
+          # Check if it's a local file (not URL)
+          if obj.start_with?('http://', 'https://', 'ftp://')
+            false  # Telegram handles URLs directly
+          else
+            File.exist?(obj) && File.readable?(obj)
+          end
+        else
+          false
+        end
       end
     end
 
+    # Custom Errors
     class APIError < StandardError
       attr_reader :code
       
@@ -132,5 +197,14 @@ module Telegem
     end
 
     class NetworkError < APIError; end
+    
+    class RateLimitError < APIError
+      attr_reader :retry_after
+      
+      def initialize(message, retry_after = 1)
+        super(message)
+        @retry_after = retry_after
+      end
+    end
   end
 end