telegem 0.2.5 → 1.0.0

data/lib/api/client.rb

@@ -1,163 +1,136 @@
-require 'async'
-require 'async/http'
-require 'json'
-require 'logger'
-require 'mime/types'
-require 'securerandom'
-require 'ostruct'
+# lib/api/client.rb - CORRECTED VERSION
+require 'httpx'
 
 module Telegem
   module API
     class Client
       BASE_URL = 'https://api.telegram.org'
+      
+      attr_reader :token, :logger, :http
 
-      attr_reader :token, :logger
-
-      def initialize(token, endpoint: nil, logger: nil)
+      def initialize(token, logger: nil, timeout: 30)
         @token = token
         @logger = logger || Logger.new($stdout)
-        @endpoint = endpoint || Async::HTTP::Endpoint.parse("#{BASE_URL}/bot#{token}")
-        @client = nil
-        @semaphore = Async::Semaphore.new(30)
+        
+        # HTTPX with persistent connections and proper async support
+        @http = HTTPX.plugin(:persistent)
+                     .plugin(:retries, max_retries: 3, retry_on: [Timeout::Error, HTTPX::Error])
+                     .with(
+                       timeout: { 
+                         connect_timeout: 10,
+                         write_timeout: 10,
+                         read_timeout: timeout,
+                         keep_alive_timeout: 15
+                       },
+                       headers: {
+                         'Content-Type' => 'application/json',
+                         'User-Agent' => "Telegem/#{Telegem::VERSION}"
+                       }
+                     )
       end
 
+      # Main API call - returns HTTPX request (promise-like object)
       def call(method, params = {})
-        Async do |task|
-          @semaphore.async do
-            make_request(method, clean_params(params))
-          end
-        end
+        url = "#{BASE_URL}/bot#{@token}/#{method}"
+        
+        @logger.debug("API Call: #{method}") if @logger
+        
+        # Return the async request object directly
+        @http.post(url, json: params.compact)
+             .then(&method(:handle_response))
+             .on_error(&method(:handle_error))
       end
 
+      # File upload method
       def upload(method, params)
-        Async do |task|
-          @semaphore.async do
-            make_multipart_request(method, params)
+        url = "#{BASE_URL}/bot#{@token}/#{method}"
+        
+        # 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]
           end
         end
+        
+        @http.post(url, form: form)
+             .then(&method(:handle_response))
+             .on_error(&method(:handle_error))
       end
 
-      def get_updates(offset: nil, timeout: 30, limit: 100)
+      # Convenience method for getUpdates with proper async handling
+      def get_updates(offset: nil, timeout: 30, limit: 100, allowed_updates: nil)
         params = { timeout: timeout, limit: limit }
         params[:offset] = offset if offset
+        params[:allowed_updates] = allowed_updates if allowed_updates
+        
         call('getUpdates', params)
       end
 
+      # Close connections gracefully
       def close
-        @client&.close
-      end
-
-      private
-
-      def make_request(method, params)
-        with_client do |client|
-          headers = { 'content-type' => 'application/json' }
-          body = params.to_json
-
-          response = client.post("/bot#{@token}/#{method}", headers, body)
-          handle_response(response)
-        end
-      end
-
-      def make_multipart_request(method, params)
-        with_client do |client|
-          form = build_multipart(params)
-          headers = form.headers
-
-          response = client.post("/bot#{@token}/#{method}", headers, form.body)
-          handle_response(response)
-        end
-      end
-
-      def with_client(&block)
-        @client ||= Async::HTTP::Client.new(@endpoint)
-        yield @client
-      end
-
-      def clean_params(params)
-        params.reject { |_, v| v.nil? }
-      end
-
-      def build_multipart(params)
-        boundary = SecureRandom.hex(16)
-        parts = []
-
-        params.each do |key, value|
-          if file?(value)
-            parts << part_from_file(key, value, boundary)
-          else
-            parts << part_from_field(key, value, boundary)
-          end
-        end
-
-        parts << "--#{boundary}--\r\n"
-
-        body = parts.join
-        headers = {
-          'content-type' => "multipart/form-data; boundary=#{boundary}",
-          'content-length' => body.bytesize.to_s
-        }
-
-        OpenStruct.new(headers: headers, body: body)
+        @http.close
       end
 
-      def file?(value)
-        value.is_a?(File) || 
-        value.is_a?(StringIO) || 
-        (value.is_a?(String) && File.exist?(value))
+      # 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
 
-      def part_from_file(key, file, boundary)
-        filename = File.basename(file.path) if file.respond_to?(:path)
-        filename ||= "file"
-
-        mime_type = MIME::Types.type_for(filename).first || 'application/octet-stream'
-
-        content = if file.is_a?(String)
-                    File.read(file)
-                  else
-                    file.read
-                  end
-
-        <<~PART
-          --#{boundary}\r
-          Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r
-          Content-Type: #{mime_type}\r
-          \r
-          #{content}\r
-        PART
-      end
-
-      def part_from_field(key, value, boundary)
-        <<~PART
-          --#{boundary}\r
-          Content-Disposition: form-data; name="#{key}"\r
-          \r
-          #{value}\r
-        PART
-      end
+      private
 
       def handle_response(response)
-        body = response.read
-        json = JSON.parse(body)
-
+        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']
         else
           raise APIError.new(json['description'], json['error_code'])
         end
-      rescue JSON::ParserError
-        raise APIError, "Invalid JSON response: #{body[0..100]}"
+      end
+
+      def handle_error(error, request = nil)
+        case error
+        when HTTPX::TimeoutError
+          @logger.error("Telegram API timeout: #{error.message}") if @logger
+          raise NetworkError, "Request timeout: #{error.message}"
+        when HTTPX::ConnectionError
+          @logger.error("Connection error: #{error.message}") if @logger
+          raise NetworkError, "Connection failed: #{error.message}"
+        when HTTPX::HTTPError
+          @logger.error("HTTP error #{error.response.status}: #{error.message}") if @logger
+          raise APIError, "HTTP #{error.response.status}: #{error.message}"
+        else
+          @logger.error("Unexpected error: #{error.class}: #{error.message}") if @logger
+          raise APIError, error.message
+        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))
       end
     end
 
     class APIError < StandardError
       attr_reader :code
-
+      
       def initialize(message, code = nil)
         super(message)
         @code = code
       end
     end
+
+    class NetworkError < APIError; end
   end
 end

data/lib/core/bot.rb

@@ -5,7 +5,7 @@ module Telegem
 
       def initialize(token, **options)
         @token = token
-        @api = API::Client.new(token, **options.slice(:endpoint, :logger))
+        @api = API::Client.new(token, **options.slice(:logger, :timeout))
         @handlers = {
           message: [],
           callback_query: [],
@@ -20,10 +20,9 @@ module Telegem
         @logger = options[:logger] || Logger.new($stdout)
         @error_handler = nil
         @session_store = options[:session_store] || Session::MemoryStore.new
-        @concurrency = options[:concurrency] || 10
-        @semaphore = Async::Semaphore.new(@concurrency)
-        @polling_task = nil
+        @polling_thread = nil
         @running = false
+        @offset = nil
       end
 
       def command(name, **options, &block)
@@ -61,43 +60,28 @@ module Telegem
       end
 
       def start_polling(**options)
-        return @polling_task if @running
+        return if @running
         
-        @polling_task = Async do |parent|
-          @running = true
-          @logger.info "Starting async polling..."
-          offset = nil
-
-          begin
-            loop do
-              updates_task = fetch_updates(offset, **options)
-              updates_data = updates_task.wait
-              updates = updates_data.map { |data| Types::Update.new(data) }
-
-              updates.each do |update|
-                parent.async do |child|
-                  @semaphore.async do
-                    process_update(update)
-                  end
-                end
-              end
-
-              offset = updates.last&.update_id.to_i + 1 if updates.any?
-            end
-          rescue => e
-            handle_error(e)
-            raise
-          ensure
-            @running = false
-          end
+        @running = true
+        @polling_options = {
+          timeout: 30,
+          limit: 100,
+          allowed_updates: nil
+        }.merge(options)
+        
+        @offset = nil
+        
+        @polling_thread = Thread.new do
+          @logger.info "🤖 Starting Telegem bot (HTTPX async)..."
+          poll_loop
         end
         
-        @polling_task
+        self
       end
 
       def webhook(app = nil, &block)
-        require_relative '../../webhook/server'
-
+        require 'telegem/webhook/server'
+        
         if block_given?
           Webhook::Server.new(self, &block)
         elsif app
@@ -108,42 +92,30 @@ module Telegem
       end
 
       def set_webhook(url, **options)
-        Async do
-          params = { url: url }.merge(options)
-          await @api.call('setWebhook', params)
-        end
+        @api.call('setWebhook', { url: url }.merge(options))
       end
 
       def delete_webhook
-        Async do
-          await @api.call('deleteWebhook', {})
-        end
+        @api.call('deleteWebhook', {})
       end
 
       def get_webhook_info
-        Async do
-          await @api.call('getWebhookInfo', {})
-        end
+        @api.call('getWebhookInfo', {})
       end
 
       def process(update_data)
-        Async do
-          update = Types::Update.new(update_data)
-          await process_update(update)
-        end
+        update = Types::Update.new(update_data)
+        process_update(update)
       end
 
       def shutdown
-        @logger.info "Shutting down..."
+        @logger.info "🛑 Shutting down..."
         
-        if @polling_task && @polling_task.running?
-          @polling_task.stop
-          @polling_task = nil
-        end
-        
-        @api.close
         @running = false
-        @logger.info "Bot stopped"
+        @polling_thread&.join(5) if @polling_thread&.alive?
+        @api.close
+        
+        @logger.info "✅ Bot stopped"
       end
 
       def running?
@@ -152,26 +124,74 @@ module Telegem
 
       private
 
-      def fetch_updates(offset, timeout: 30, limit: 100, allowed_updates: nil)
-        params = { timeout: timeout, limit: limit }
-        params[:offset] = offset if offset
-        params[:allowed_updates] = allowed_updates if allowed_updates
-
-        @api.get_updates(**params)
+      def poll_loop
+        while @running
+          begin
+            # Get updates - returns HTTPX request immediately
+            updates_request = fetch_updates
+            
+            # Wait for this poll to complete (with timeout)
+            response = updates_request.wait(@polling_options[:timeout] + 5)
+            
+            if response && response.status == 200 && response.json
+              handle_updates_response(response.json)
+            end
+            
+            # Small delay to prevent tight loop on errors
+            sleep 0.1 unless @offset.nil?
+            
+          rescue => e
+            handle_error(e)
+            # Longer delay on error
+            sleep 5
+          end
+        end
       end
 
-      def process_update(update)
-        Async do
-          ctx = Context.new(update, self)
+      def fetch_updates
+        params = {
+          timeout: @polling_options[:timeout],
+          limit: @polling_options[:limit]
+        }
+        params[:offset] = @offset if @offset
+        params[:allowed_updates] = @polling_options[:allowed_updates] if @polling_options[:allowed_updates]
+        
+        @api.call('getUpdates', params)
+      end
 
-          begin
-            await run_middleware_chain(ctx) do |context|
-              await dispatch_to_handlers(context)
+      def handle_updates_response(api_response)
+        return unless api_response['ok']
+        
+        updates_data = api_response['result'] || []
+        
+        # Process each update in its own thread for concurrency
+        updates_data.each do |update_data|
+          Thread.new do
+            begin
+              update = Types::Update.new(update_data)
+              process_update(update)
+            rescue => e
+              @logger.error("Error in update thread: #{e.message}")
             end
-          rescue => e
-            await handle_error(e, ctx)
           end
         end
+        
+        # Update offset for next poll
+        if updates_data.any?
+          @offset = updates_data.last['update_id'] + 1
+        end
+      end
+
+      def process_update(update)
+        ctx = Context.new(update, self)
+        
+        begin
+          run_middleware_chain(ctx) do |context|
+            dispatch_to_handlers(context)
+          end
+        rescue => e
+          handle_error(e, ctx)
+        end
       end
 
       def run_middleware_chain(ctx, &final)
@@ -199,16 +219,13 @@ module Telegem
       end
 
       def dispatch_to_handlers(ctx)
-        Async do
-          update_type = detect_update_type(ctx.update)
-          handlers = @handlers[update_type] || []
-
-          handlers.each do |handler|
-            if matches_filters?(ctx, handler[:filters])
-              result = handler[:handler].call(ctx)
-              result = await(result) if result.is_a?(Async::Task)
-              break
-            end
+        update_type = detect_update_type(ctx.update)
+        handlers = @handlers[update_type] || []
+
+        handlers.each do |handler|
+          if matches_filters?(ctx, handler[:filters])
+            handler[:handler].call(ctx)
+            break  # First matching handler wins
           end
         end
       end
@@ -236,13 +253,7 @@ module Telegem
           when :command
             matches_command_filter(ctx, value)
           else
-            if value.respond_to?(:call)
-              result = value.call(ctx)
-              result = await(result) if result.is_a?(Async::Task)
-              result
-            else
-              ctx.update.send(key) == value
-            end
+            ctx.update.send(key) == value
           end
         end
       end
@@ -269,11 +280,11 @@ module Telegem
 
       def handle_error(error, ctx = nil)
         if @error_handler
-          result = @error_handler.call(error, ctx)
-          await(result) if result.is_a?(Async::Task)
+          @error_handler.call(error, ctx)
         else
-          @logger.error("Unhandled error: #{error.class}: #{error.message}")
-          @logger.error(error.backtrace.join("\n")) if error.backtrace
+          @logger.error("❌ Unhandled error: #{error.class}: #{error.message}")
+          @logger.error("Context: #{ctx.raw_update}") if ctx
+          @logger.error(error.backtrace&.join("\n")) if error.backtrace
         end
       end
     end

data/lib/core/composer.rb

@@ -1,3 +1,4 @@
+# lib/core/composer.rb - HTTPX VERSION (NO ASYNC GEM)
 module Telegem
   module Core
     class Composer
@@ -13,24 +14,14 @@ module Telegem
       def call(ctx, &final)
         return final.call(ctx) if @middleware.empty?
 
-        # Build async-aware chain
+        # Build the middleware chain
         chain = final
-
+        
+        # Reverse the middleware so last added runs last in chain
         @middleware.reverse_each do |middleware|
-          chain = ->(context) do
-            if middleware.respond_to?(:call)
-              result = middleware.call(context, chain)
-              result.is_a?(Async::Task) ? result : Async::Task.new(result)
-            elsif middleware.is_a?(Class)
-              instance = middleware.new
-              result = instance.call(context, chain)
-              result.is_a?(Async::Task) ? result : Async::Task.new(result)
-            else
-              raise "Invalid middleware: #{middleware.class}"
-            end
-          end
+          chain = create_middleware_wrapper(middleware, chain)
         end
-
+        
         # Execute the chain
         chain.call(ctx)
       end
@@ -38,6 +29,33 @@ module Telegem
       def empty?
         @middleware.empty?
       end
-    end 
-  end 
-end 
+
+      private
+
+      def create_middleware_wrapper(middleware, next_middleware)
+        ->(context) do
+          middleware_instance = instantiate_middleware(middleware)
+          
+          if middleware_instance.respond_to?(:call)
+            # Call the middleware with next in chain
+            middleware_instance.call(context, next_middleware)
+          else
+            raise "Invalid middleware: #{middleware.class}"
+          end
+        end
+      end
+
+      def instantiate_middleware(middleware)
+        case middleware
+        when Class
+          middleware.new
+        when Proc, Method
+          middleware
+        else
+          # Assume it's already a middleware instance
+          middleware
+        end
+      end
+    end
+  end
+end