telegem 3.4.0 → 3.6.0

data/lib/api/client.rb

@@ -1,11 +1,112 @@
-require 'async/http'
-require 'json'
+require "async/http"
+require "json"
+require "logger"
+require "securerandom"
+require "stringio"
+require "tempfile"
 
 module Telegem
   module API
+    class MultipartForm
+      CRLF = "\r\n"
+
+      attr_reader :content_type
+
+      def initialize
+        @boundary = "----telegem#{SecureRandom.hex(16)}"
+        @content_type = "multipart/form-data; boundary=#{@boundary}"
+        @parts = []
+      end
+
+      def add(name, value)
+        if file?(value)
+          append_file(name, value)
+        else
+          append_field(name, value.to_s)
+        end
+      end
+
+      def body
+        String.new.tap do |buffer|
+          @parts.each do |part|
+            buffer << "--#{@boundary}#{CRLF}"
+            buffer << part
+            buffer << CRLF
+          end
+
+          buffer << "--#{@boundary}--#{CRLF}"
+        end
+      end
+
+      private
+
+      def append_field(name, value)
+        @parts << <<~PART.gsub("\n", CRLF)
+          Content-Disposition: form-data; name="#{name}"
+
+          #{value}
+        PART
+      end
+
+      def append_file(name, value)
+        io =
+          case value
+          when String
+            File.open(value, "rb")
+          else
+            value
+          end
+
+        filename =
+          if io.respond_to?(:path) && io.path
+            File.basename(io.path)
+          else
+            "upload.bin"
+          end
+
+        mime =
+          case File.extname(filename).downcase
+          when ".jpg", ".jpeg"
+            "image/jpeg"
+          when ".png"
+            "image/png"
+          when ".gif"
+            "image/gif"
+          when ".webp"
+            "image/webp"
+          when ".mp4"
+            "video/mp4"
+          when ".mp3"
+            "audio/mpeg"
+          when ".ogg"
+            "audio/ogg"
+          when ".pdf"
+            "application/pdf"
+          else
+            "application/octet-stream"
+          end
+
+        @parts << String.new.tap do |part|
+          part << %(Content-Disposition: form-data; name="#{name}"; filename="#{filename}") << CRLF
+          part << "Content-Type: #{mime}" << CRLF
+          part << CRLF
+          part << io.read
+        end
+
+        io.close if value.is_a?(String)
+      end
+
+      def file?(obj)
+        obj.is_a?(File) ||
+          obj.is_a?(Tempfile) ||
+          obj.is_a?(StringIO) ||
+          (obj.is_a?(String) && File.file?(obj))
+      end
+    end
+
     class Client
-      BASE_URL = 'https://api.telegram.org'
-      
+      BASE_URL = "https://api.telegram.org"
+
       attr_reader :token, :logger
 
       def initialize(token, **options)
@@ -13,20 +114,21 @@ module Telegem
         @logger = options[:logger] || Logger.new($stdout)
         @timeout = options[:timeout] || 30
         @retries = options[:retries] || 3
-        @retry_delay = options[:retry_delay] || 1  # seconds
-        
+        @retry_delay = options[:retry_delay] || 1
+
         @endpoint = Async::HTTP::Endpoint.parse(BASE_URL, timeout: @timeout)
         @client = Async::HTTP::Client.new(@endpoint)
       end
-      
+
       def call(method, params = {})
         with_retry do
           make_request(method, params)
         end
       end
-      
+
       def call!(method, params = {}, &callback)
         return unless callback
+
         begin
           result = call(method, params)
           callback.call(result, nil)
@@ -34,38 +136,45 @@ module Telegem
           callback.call(nil, error)
         end
       end
-      
+
       def upload(method, params)
         with_retry do
           url = "/bot#{@token}/#{method}"
-          
-          body = Async::HTTP::Body::Multipart.new
-          
+
+          form = MultipartForm.new
+
           params.each do |key, value|
-            if file_object?(value)
-              body.add(key.to_s, value, filename: File.basename(value))
-            else
-              body.add(key.to_s, value.to_s)
-            end
+            form.add(key.to_s, value)
           end
-          
-          response = @client.post(url, {}, body)
+
+          body = form.body
+
+          response = @client.post(
+            url,
+            {
+              "content-type" => form.content_type,
+              "content-length" => body.bytesize.to_s
+            },
+            body
+          )
+
           handle_response(response)
         end
       end
-      
+
       def download(file_id, destination_path = nil)
         with_retry do
-          file_info = call('getFile', file_id: file_id)
-          return nil unless file_info && file_info['file_path']
-          
-          file_path = file_info['file_path']
+          file_info = call("getFile", file_id: file_id)
+          return nil unless file_info && file_info["file_path"]
+
+          file_path = file_info["file_path"]
           download_url = "/file/bot#{@token}/#{file_path}"
-          
+
           response = @client.get(download_url)
-          
+
           if response.status == 200
             content = response.read
+
             if destination_path
               File.binwrite(destination_path, content)
               destination_path
@@ -77,78 +186,90 @@ module Telegem
           end
         end
       end
-      
+
       def get_updates(offset: nil, timeout: 30, limit: 100, allowed_updates: nil)
-        params = { timeout: timeout, limit: limit }
+        params = {
+          timeout: timeout,
+          limit: limit
+        }
+
         params[:offset] = offset if offset
         params[:allowed_updates] = allowed_updates if allowed_updates
-        call('getUpdates', params)
+
+        call("getUpdates", params)
       end
-      
+
       def close
         @client.close
       end
-      
+
       private
-      
-      def with_retry(&block)
+
+      def with_retry
         retries = 0
+
         begin
-          block.call
+          yield
         rescue NetworkError, Async::TimeoutError => e
           retries += 1
+
           if retries <= @retries
             @logger.warn("API request failed: #{e.message}. Retry #{retries}/#{@retries}") if @logger
-            sleep @retry_delay * retries  # exponential backoff
+            sleep(@retry_delay * retries)
             retry
           else
             raise
           end
-        rescue APIError => e
-          # Don't retry API errors (bad request, unauthorized, etc.)
+        rescue APIError
           raise
         end
       end
-      
+
       def make_request(method, params)
         url = "/bot#{@token}/#{method}"
-        @logger.debug("Api call #{method}") if @logger
-        
+
+        @logger.debug("API call #{method}") if @logger
+
         response = @client.post(
           url,
-          { 'content-type' => 'application/json' },
+          {
+            "content-type" => "application/json"
+          },
           JSON.dump(params.compact)
         )
-        
+
         handle_response(response)
       end
-      
+
       def handle_response(response)
         json = JSON.parse(response.read)
-        
-        if json && json['ok']
-          json['result']
+
+        if json["ok"]
+          json["result"]
         else
-          error_msg = json ? json['description'] : "HTTP #{response.status} - Empty response"
+          error_msg = json["description"] || "HTTP #{response.status}"
           raise APIError.new(error_msg, response.status)
         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))
+        obj.is_a?(File) ||
+          obj.is_a?(StringIO) ||
+          obj.is_a?(Tempfile) ||
+          (obj.is_a?(String) && File.file?(obj))
       end
     end
-    
+
     class APIError < StandardError
       attr_reader :code
-      
+
       def initialize(message, code = nil)
         super(message)
         @code = code
       end
     end
-    
-    class NetworkError < APIError; end
+
+    class NetworkError < APIError
+    end
   end
-end
+end

data/lib/api/types.rb

@@ -53,10 +53,7 @@ module Telegem
         elsif @_raw_data.key?(camel_key)
           define_singleton_method(name) { @_raw_data[camel_key] }
         else
-          define_singleton_method(name) do
-            raise NoMethodError,
-                  "undefined method `#{name}' for #{self.class} with keys: #{@_raw_data.keys}"
-          end
+          define_singleton_method(name) { nil } 
         end
 
         @_accessors_defined[name] = true
@@ -91,7 +88,8 @@ module Telegem
                         can_join_groups can_read_all_group_messages
                         supports_inline_queries language_code
                         is_premium added_to_attachment_menu
-                        can_connect_to_business can_manage_bots].freeze
+                        can_connect_to_business can_manage_bots
+                        supports_guest_queries].freeze
 
       def initialize(data)
         super(data)
@@ -191,7 +189,9 @@ module Telegem
                         forward_from_message_id forward_signature
                         forward_sender_name forward_date reply_to_message
                         media_group_id author_signature
-                        has_protected_content managed_bot_created managed_bot].freeze
+                        has_protected_content managed_bot_created managed_bot
+                        guest_bot_caller_user guest_bot_caller_chat
+                        guest_query_id live_photo].freeze
 
       def initialize(data)
         super(data)
@@ -301,6 +301,10 @@ module Telegem
         wrap('voice', Voice)
         wrap('video_note', VideoNote)
         wrap('sticker', Sticker)
+        wrap('live_photo', LivePhoto)
+
+        wrap('guest_bot_caller_user', User)
+        wrap('guest_bot_caller_chat', Chat)
 
         wrap('invoice', Invoice)
         wrap('successful_payment', SuccessfulPayment)
@@ -409,7 +413,8 @@ module Telegem
                         edited_channel_post inline_query chosen_inline_result
                         callback_query shipping_query pre_checkout_query
                         poll poll_answer my_chat_member chat_member
-                        chat_join_request managed_bot_created managed_bot].freeze
+                        chat_join_request managed_bot_created managed_bot
+                        guest_message].freeze
 
       def initialize(data)
         super(data)
@@ -438,6 +443,7 @@ module Telegem
         return :chat_join_request if chat_join_request
         return :managed_bot_created if managed_bot_created
         return :managed_bot if managed_bot
+        return :guest_message if guest_message
         :unknown
       end
 
@@ -463,6 +469,8 @@ module Telegem
           chat_join_request.from
         when :managed_bot_created, :managed_bot
           managed_bot_created&.from || managed_bot&.from
+        when :guest_message
+          guest_message.from
         else
           nil
         end
@@ -497,6 +505,8 @@ module Telegem
         # Bot API 9.6 - Managed Bot Support
         wrap('managed_bot_created', ManagedBotCreated)
         wrap('managed_bot', ManagedBotUpdated)
+        # Bot API 10.0 - Guest Message Support
+        wrap('guest_message', SentGuestMessage)
       end
     end
 
@@ -546,6 +556,8 @@ module Telegem
         # Bot API 9.6 enhancements
         wrap('added_by_user', User)
         wrap('added_by_chat', Chat)
+        # Bot API 10.0 - media support
+        wrap('media', InputPollOptionMedia)
       end
     end
 
@@ -556,10 +568,19 @@ module Telegem
         super(data)
         wrap_array('options', PollOption)
         wrap_array('explanation_entities', MessageEntity)
+        # Bot API 10.0 - poll media support
+        wrap('media', PollMedia)
+        wrap('explanation_media', PollMedia)
       end
     end
 
-    class ChatPermissions < BaseType; end
+    class ChatPermissions < BaseType
+      def initialize(data)
+        super(data)
+        # Bot API 10.0 - reaction support
+        define_accessor(:can_react_to_messages)
+      end
+    end
     class ChatPhoto < BaseType; end
     class ChatInviteLink < BaseType; end
 
@@ -568,7 +589,13 @@ module Telegem
     class ChatMemberOwner < ChatMember; end
     class ChatMemberAdministrator < ChatMember; end
     class ChatMemberMember < ChatMember; end
-    class ChatMemberRestricted < ChatMember; end
+    class ChatMemberRestricted < ChatMember
+      def initialize(data)
+        super(data)
+        # Bot API 10.0 - reaction support
+        define_accessor(:can_react_to_messages)
+      end
+    end
     class ChatMemberLeft < ChatMember; end
     class ChatMemberBanned < ChatMember; end
 
@@ -699,5 +726,29 @@ module Telegem
     class ManagedBotCreated < BaseType; end
     class ManagedBotDeleted < BaseType; end
     class ManagedBotUpdated < BaseType; end
+
+    # Bot API 10.0 - Guest Mode Support
+    class SentGuestMessage < BaseType; end
+
+    # Bot API 10.0 - Poll Media Support
+    class PollMedia < BaseType; end
+    class InputPollMedia < BaseType; end
+    class InputPollOptionMedia < BaseType; end
+
+    # Bot API 10.0 - Live Photo Support
+    class LivePhoto < BaseType
+      def initialize(data)
+        super(data)
+        wrap('photo', PhotoSize)
+        wrap('video', Video)
+      end
+    end
+
+    class InputMediaLivePhoto < BaseType; end
+    class PaidMediaLivePhoto < BaseType; end
+    class InputPaidMediaLivePhoto < BaseType; end
+
+    # Bot API 10.0 - Business Access Settings
+    class BotAccessSettings < BaseType; end
     end
   end

data/lib/core/context.rb

@@ -124,6 +124,62 @@ module Telegem
         params = { chat_id: chat.id, text: text }.merge(options)
         @bot.api.call('sendMessage', params)
       end
+
+      def reply_rich(rich_message, **options)
+       return nil unless chat
+  
+       params = { chat_id: chat.id, rich_message: rich_message }.merge(options)
+       @bot.api.call('sendRichMessage', params)
+      end
+
+      # Draft streaming support (Bot API 10.1)
+def start_draft(initial_text = "", **options)
+  return nil unless chat
+  
+  draft_id = "draft_#{chat.id}_#{Time.now.to_i}_#{rand(1000)}"
+  session[:telegem_draft_id] = draft_id
+  
+  rich_message = { blocks: [{ type: "paragraph", content: initial_text }] }
+  params = { chat_id: chat.id, draft_id: draft_id, rich_message: rich_message }.merge(options)
+  @bot.api.call('sendRichMessageDraft', params)
+  
+  draft_id
+end
+
+def append_to_draft(draft_id = nil, content, **options)
+  return nil unless chat
+  
+  draft_id ||= session[:telegem_draft_id]
+  return nil unless draft_id
+  
+  rich_message = { blocks: [{ type: "paragraph", content: content }] }
+  params = { chat_id: chat.id, draft_id: draft_id, rich_message: rich_message }.merge(options)
+  @bot.api.call('sendRichMessageDraft', params)
+end
+
+def publish_draft(draft_id = nil, **options)
+  return nil unless chat
+  
+  draft_id ||= session[:telegem_draft_id]
+  return nil unless draft_id
+  
+  params = { chat_id: chat.id, draft_id: draft_id }.merge(options)
+  result = @bot.api.call('publishRichMessageDraft', params)
+  session.delete(:telegem_draft_id)
+  result
+end
+
+def cancel_draft(draft_id = nil, **options)
+  return nil unless chat
+  
+  draft_id ||= session[:telegem_draft_id]
+  return nil unless draft_id
+  
+  params = { chat_id: chat.id, draft_id: draft_id }.merge(options)
+  result = @bot.api.call('cancelRichMessageDraft', params)
+  session.delete(:telegem_draft_id)
+  result
+end
       
       def edit_message_text(text, **options)
         return nil unless message && chat

data/lib/core/rate_limit.rb

@@ -63,7 +63,6 @@ module Telegem
     end
     
     def increment_counters(ctx)
-      now = Time.now.to_i
       if @options[:global]
         key = "global"
         @counters[:global].increment(key, 1, ttl: @options[:global][:per])
@@ -80,8 +79,12 @@ module Telegem
       end
     end
     def rate_limit_response(ctx)
-      ctx.reply("⏳ Please wait a moment before sending another request.") rescue nil
+      begin
+        ctx.reply("⏳ Please wait a moment before sending another request.")
+      rescue StandardError => e
+        ctx.logger&.warn("Failed to send rate limit response: #{e.class}: #{e.message}")
+      end
       nil
     end
   end 
-end
+end

data/lib/telegem.rb

@@ -3,7 +3,7 @@ require 'logger'
 require 'json'
 
 module Telegem
-  VERSION = "3.4.0"
+  VERSION = "3.6.0"
 end
 
 #

data/lib/webhook/server.rb

@@ -104,28 +104,38 @@ module Telegem
       end
 
       def handle_request(request)
-        case request.path
-        when @secret_token, "/#{@secret_token}"
-          handle_webhook_request(request)
-        when '/health', '/healthz'
-          health_endpoint(request)
-        else
-          [404, {}, ["Not Found"]]
+        begin
+          case request.path
+          when @secret_token, "/#{@secret_token}"
+            handle_webhook_request(request)
+          when '/health', '/healthz'
+            health_endpoint(request)
+          else
+            [404, {}, ["Not Found"]]
+          end
+        rescue => e
+          @logger.error("Request handler error: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}")
+          [500, {}, ["Internal Server Error"]]
         end
       end
 
       def handle_webhook_request(request)
         return [405, {}, ["Method Not Allowed"]] unless request.post?
+        
         received = request.headers['X-Telegram-Bot-Api-Secret-Token'] ||
-           request.headers['x-telegram-bot-api-secret-token']
-        return [403, {}, ["Forbidden"]] unless received  == @secret_token
+                   request.headers['x-telegram-bot-api-secret-token']
+        return [403, {}, ["Forbidden"]] unless received == @secret_token
 
         begin
           body = request.body.read
-          update_data = JSON.parse(body)
-           process_webhook_update(update_data) 
+          update_data = json_to_symbols(JSON.parse(body))
+          process_webhook_update(update_data)
           [200, {}, ["OK"]]
-        rescue
+        rescue JSON::ParserError => e
+          @logger.error("JSON parse error: #{e}")
+          [400, {}, ["Bad Request"]]
+        rescue => e
+          @logger.error("Webhook handler error: #{e.class} - #{e.message}")
           [500, {}, ["Internal Server Error"]]
         end
       end
@@ -137,11 +147,12 @@ module Telegem
       end
 
       def health_endpoint(request)
-        [200, { 'Content-Type' => 'application/json' }, [{
+        body = {
           status: 'ok',
           mode: @ssl_mode.to_s,
           ssl: @ssl_mode != :none
-        }.to_json]]
+        }.to_json
+        [200, { 'Content-Type' => 'application/json' }, [body]]
       end
 
       def stop
@@ -183,6 +194,17 @@ module Telegem
       def running?
         @running
       end
+
+      def json_to_symbols(obj)
+         case obj
+           when Hash
+            obj.transform_keys { |k| k.to_sym }.transform_values { |v| json_to_symbols(v) }
+           when Array
+            obj.map { |v| json_to_symbols(v) }
+           else
+            obj
+          end
+      end
     end
   end
 end