telegem 0.2.0 → 1.0.0

data/lib/api/client.rb

@@ -1,156 +1,136 @@
-      module Telegem
-        module API
-          class Client
-            BASE_URL = 'https://api.telegram.org'
-
-            attr_reader :token, :logger
-
-            def initialize(token, endpoint: nil, logger: nil)
-              @token = token
-              @logger = logger || Logger.new($stdout)
-              @endpoint = endpoint || Async::HTTP::Endpoint.parse("#{BASE_URL}/bot#{token}")
-              @client = nil
-              @semaphore = Async::Semaphore.new(30)
-            end
-
-            def call(method, params = {})
-              Async do |task|
-                @semaphore.async do
-                  make_request(method, clean_params(params))
-                end
-              end
-            end
-
-            def upload(method, params)
-              Async do |task|
-                @semaphore.async do
-                  make_multipart_request(method, params)
-                end
-              end
-            end
-
-            def get_updates(offset: nil, timeout: 30, limit: 100)
-              params = { timeout: timeout, limit: limit }
-              params[:offset] = offset if offset
-              call('getUpdates', params)
-            end
-
-            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)
-              # Build multipart form data for file uploads
-              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)
-            end
-
-            def file?(value)
-              value.is_a?(File) || 
-              value.is_a?(StringIO) || 
-              (value.is_a?(String) && File.exist?(value))
-            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
-
-            def handle_response(response)
-              body = response.read
-              json = JSON.parse(body)
-
-              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
-          end
-
-          class APIError < StandardError
-            attr_reader :code
-
-            def initialize(message, code = nil)
-              super(message)
-              @code = code
-            end
+# 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
+
+      def initialize(token, logger: nil, timeout: 30)
+        @token = token
+        @logger = logger || Logger.new($stdout)
+        
+        # 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 = {})
+        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)
+        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
-      end
+        
+        @http.post(url, form: form)
+             .then(&method(:handle_response))
+             .on_error(&method(:handle_error))
+      end
+
+      # 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
+        @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)
+        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
+      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,42 +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 = updates_task.wait
-
-              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
@@ -107,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..."
-        
-        if @polling_task && @polling_task.running?
-          @polling_task.stop
-          @polling_task = nil
-        end
+        @logger.info "🛑 Shutting down..."
         
-        @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?
@@ -151,32 +124,74 @@ module Telegem
 
       private
 
-      def fetch_updates(offset, timeout: 30, limit: 100, allowed_updates: nil)
-        Async do
-          params = { timeout: timeout, limit: limit }
-          params[:offset] = offset if offset
-          params[:allowed_updates] = allowed_updates if allowed_updates
-
-          updates = await @api.get_updates(**params)
-          updates.map { |data| Types::Update.new(data) }
-        rescue API::APIError => e
-          @logger.error "Failed to fetch updates: #{e.message}"
-          []
+      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)
@@ -204,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
@@ -241,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
@@ -274,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