@codebam/cf-workers-telegram-bot 8.1.1 → 9.0.0

package/dist/telegram_api.d.ts

@@ -1,79 +1,149 @@
 import TelegramInlineQueryResultArticle from './types/TelegramInlineQueryResultArticle.js';
 import TelegramInlineQueryResultPhoto from './types/TelegramInlineQueryResultPhoto.js';
 import TelegramInlineQueryResultVideo from './types/TelegramInlineQueryResultVideo.js';
-/** Class representing the Telegram API and all it's methods */
+/** Interface for common Telegram API parameters */
+interface TelegramApiBaseParams {
+    chat_id: number | string;
+    business_connection_id?: string | number;
+}
+/** Interface for message parameters */
+interface SendMessageParams extends TelegramApiBaseParams {
+    text: string;
+    parse_mode: string;
+    reply_to_message_id?: number | string;
+    disable_web_page_preview?: boolean;
+    disable_notification?: boolean;
+    protect_content?: boolean;
+    reply_markup?: object;
+}
+/** Interface for photo parameters */
+interface SendPhotoParams extends TelegramApiBaseParams {
+    photo: string;
+    caption?: string;
+    parse_mode?: string;
+    reply_to_message_id?: number | string;
+    disable_notification?: boolean;
+    protect_content?: boolean;
+    reply_markup?: object;
+}
+/** Interface for video parameters */
+interface SendVideoParams extends TelegramApiBaseParams {
+    video: string;
+    caption?: string;
+    parse_mode?: string;
+    reply_to_message_id?: number | string;
+    disable_notification?: boolean;
+    protect_content?: boolean;
+    reply_markup?: object;
+}
+/** Interface for chat action parameters */
+interface SendChatActionParams extends TelegramApiBaseParams {
+    action: string;
+}
+/** Interface for callback query parameters */
+interface AnswerCallbackParams {
+    callback_query_id: number | string;
+    text?: string;
+    show_alert?: boolean;
+    url?: string;
+    cache_time?: number;
+}
+/** Interface for inline query parameters */
+interface AnswerInlineParams {
+    inline_query_id: number | string;
+    results: TelegramInlineQueryResultArticle[] | TelegramInlineQueryResultPhoto[] | TelegramInlineQueryResultVideo[];
+    cache_time?: number;
+    is_personal?: boolean;
+    next_offset?: string;
+}
+/** Type for all possible API parameters */
+type TelegramApiParams = SendMessageParams | SendPhotoParams | SendVideoParams | SendChatActionParams | AnswerCallbackParams | AnswerInlineParams | Record<string, unknown>;
+/** Class representing the Telegram API and all its methods */
 export default class TelegramApi {
     /**
      * Get the API URL for a given bot API and slug
      * @param botApi - full URL to the telegram API without slug
      * @param slug - slug to append to the API URL
      * @param data - data to append to the request
+     * @returns Request object with the full URL and parameters
      */
-    getApiUrl(botApi: string, slug: string, data: Record<string, number | string | boolean>): Request<unknown, CfProperties<unknown>>;
-    sendChatAction(botApi: string, data: {
-        business_connection_id?: string;
-        chat_id: number | string;
-        action: string;
-    }): Promise<Response>;
+    getApiUrl(botApi: string, slug: string, data: TelegramApiParams): Request;
+    /**
+     * Send a chat action to indicate the bot is doing something
+     * @param botApi - full URL to the telegram API without slug
+     * @param data - data to append to the request
+     * @returns Promise with the API response
+     */
+    sendChatAction(botApi: string, data: SendChatActionParams): Promise<Response>;
     /**
      * Get a file with a given file_id
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
      * @param token - bot token
+     * @returns Promise with the file response
      */
-    getFile(botApi: string, data: Record<string, number | string | boolean>, token: string): Promise<Response>;
+    getFile(botApi: string, data: {
+        file_id: string;
+    } & Record<string, number | string | boolean>, token: string): Promise<Response>;
     /**
      * Send a message to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
-    sendMessage(botApi: string, data: {
-        reply_to_message_id?: number | string;
-        chat_id: number | string;
-        text: string;
-        parse_mode: string;
-        business_connection_id?: number | string;
-    }): Promise<Response>;
+    sendMessage(botApi: string, data: SendMessageParams): Promise<Response>;
     /**
      * Send a video message to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
-    sendVideo(botApi: string, data: {
-        reply_to_message_id: number | string;
-        chat_id: number | string;
-        video: string;
-    }): Promise<Response>;
+    sendVideo(botApi: string, data: SendVideoParams): Promise<Response>;
     /**
      * Send a photo message to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
-    sendPhoto(botApi: string, data: {
-        reply_to_message_id: number | string;
-        chat_id: number | string;
-        photo: string;
-        caption: string;
-    }): Promise<Response>;
+    sendPhoto(botApi: string, data: SendPhotoParams): Promise<Response>;
     /**
      * Send an inline response to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
-    answerInline(botApi: string, data: {
-        inline_query_id: number | string;
-        results: TelegramInlineQueryResultArticle[] | TelegramInlineQueryResultPhoto[] | TelegramInlineQueryResultVideo[];
+    answerInline(botApi: string, data: AnswerInlineParams): Promise<Response>;
+    /**
+     * Send a callback response to a given botApi
+     * @param botApi - full URL to the telegram API without slug
+     * @param data - data to append to the request
+     * @returns Promise with the API response
+     */
+    answerCallback(botApi: string, data: AnswerCallbackParams): Promise<Response>;
+    /**
+     * Delete a message
+     * @param botApi - full URL to the telegram API without slug
+     * @param data - data to append to the request
+     * @returns Promise with the API response
+     */
+    deleteMessage(botApi: string, data: {
+        chat_id: number | string;
+        message_id: number;
     }): Promise<Response>;
     /**
-     * Send an callback response to a given botApi
+     * Edit a message text
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
-    answerCallback(botApi: string, data: {
-        callback_query_id: number | string;
-        text?: string;
-        show_alert?: boolean;
-        url?: string;
-        cache_time?: number;
+    editMessageText(botApi: string, data: {
+        chat_id?: number | string;
+        message_id?: number;
+        inline_message_id?: string;
+        text: string;
+        parse_mode?: string;
+        disable_web_page_preview?: boolean;
+        reply_markup?: object;
     }): Promise<Response>;
 }
+export {};

package/dist/telegram_api.js

@@ -1,61 +1,75 @@
-/** Class representing the Telegram API and all it's methods */
+/** Class representing the Telegram API and all its methods */
 export default class TelegramApi {
     /**
      * Get the API URL for a given bot API and slug
      * @param botApi - full URL to the telegram API without slug
      * @param slug - slug to append to the API URL
      * @param data - data to append to the request
+     * @returns Request object with the full URL and parameters
      */
     getApiUrl(botApi, slug, data) {
         const request = new URL(botApi + (slug.startsWith('/') || botApi.endsWith('/') ? '' : '/') + slug);
         const params = new URLSearchParams();
-        for (const i in data) {
-            params.append(i, data[i].toString());
+        for (const [key, value] of Object.entries(data)) {
+            if (value !== undefined) {
+                params.append(key, typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value));
+            }
         }
         return new Request(`${request.toString()}?${params.toString()}`);
     }
+    /**
+     * Send a chat action to indicate the bot is doing something
+     * @param botApi - full URL to the telegram API without slug
+     * @param data - data to append to the request
+     * @returns Promise with the API response
+     */
     async sendChatAction(botApi, data) {
         const url = this.getApiUrl(botApi, 'sendChatAction', data);
-        const response = await fetch(url);
-        return response;
+        return await fetch(url);
     }
     /**
      * Get a file with a given file_id
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
      * @param token - bot token
+     * @returns Promise with the file response
      */
     async getFile(botApi, data, token) {
-        if (data.file_id === '') {
-            return new Response();
+        if (!data.file_id || data.file_id === '') {
+            return new Response('No file_id provided', { status: 400 });
         }
-        const url = this.getApiUrl(botApi, 'getFile', data);
-        const response = await fetch(url);
-        const json = await response.json();
-        let file_path;
         try {
-            file_path = json.result.file_path;
+            const url = this.getApiUrl(botApi, 'getFile', data);
+            const response = await fetch(url);
+            if (!response.ok) {
+                return new Response(`API error: ${String(response.status)} ${response.statusText}`, { status: response.status });
+            }
+            const json = await response.json();
+            if (!json.ok || !json.result?.file_path) {
+                return new Response(json.description ?? 'Failed to get file path', { status: 400 });
+            }
+            return await fetch(`https://api.telegram.org/file/bot${token}/${json.result.file_path}`);
         }
         catch (e) {
-            console.log(`Error: ${e}`);
-            return new Response('cant read file_path. is the file too large?');
+            console.error(`Error in getFile: ${e instanceof Error ? e.message : String(e)}`);
+            return new Response(`Error retrieving file: ${e instanceof Error ? e.message : String(e)}`, { status: 500 });
         }
-        return await fetch(`https://api.telegram.org/file/bot${token}/${file_path}`);
     }
     /**
      * Send a message to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
     async sendMessage(botApi, data) {
         const url = this.getApiUrl(botApi, 'sendMessage', data);
-        console.log(url.url);
         return await fetch(url);
     }
     /**
      * Send a video message to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
     async sendVideo(botApi, data) {
         const url = this.getApiUrl(botApi, 'sendVideo', data);
@@ -65,6 +79,7 @@ export default class TelegramApi {
      * Send a photo message to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
     async sendPhoto(botApi, data) {
         const url = this.getApiUrl(botApi, 'sendPhoto', data);
@@ -74,21 +89,46 @@ export default class TelegramApi {
      * Send an inline response to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
     async answerInline(botApi, data) {
         const url = this.getApiUrl(botApi, 'answerInlineQuery', {
             inline_query_id: data.inline_query_id,
-            results: JSON.stringify(data.results),
+            results: data.results,
+            cache_time: data.cache_time,
+            is_personal: data.is_personal,
+            next_offset: data.next_offset,
         });
         return await fetch(url);
     }
     /**
-     * Send an callback response to a given botApi
+     * Send a callback response to a given botApi
      * @param botApi - full URL to the telegram API without slug
      * @param data - data to append to the request
+     * @returns Promise with the API response
      */
     async answerCallback(botApi, data) {
         const url = this.getApiUrl(botApi, 'answerCallbackQuery', data);
         return await fetch(url);
     }
+    /**
+     * Delete a message
+     * @param botApi - full URL to the telegram API without slug
+     * @param data - data to append to the request
+     * @returns Promise with the API response
+     */
+    async deleteMessage(botApi, data) {
+        const url = this.getApiUrl(botApi, 'deleteMessage', data);
+        return await fetch(url);
+    }
+    /**
+     * Edit a message text
+     * @param botApi - full URL to the telegram API without slug
+     * @param data - data to append to the request
+     * @returns Promise with the API response
+     */
+    async editMessageText(botApi, data) {
+        const url = this.getApiUrl(botApi, 'editMessageText', data);
+        return await fetch(url);
+    }
 }

package/dist/telegram_bot.d.ts

@@ -15,17 +15,40 @@ export default class TelegramBot {
     commands: Record<string, (ctx: TelegramExecutionContext) => Promise<Response>>;
     /** The current bot context */
     currentContext: TelegramExecutionContext;
+    /** Default command to use when no matching command is found */
+    defaultCommand: string;
     /**
      *	Create a bot
      *	@param token - the telegram secret token
+     *	@param options - optional configuration for the bot
      */
-    constructor(token: string);
+    constructor(token: string, options?: {
+        defaultCommand?: string;
+    });
     /**
      * Register a function on the bot
      * @param event - the event or command name
      * @param callback - the bot context
      */
     on(event: string, callback: (ctx: TelegramExecutionContext) => Promise<Response>): this;
+    /**
+     * Register multiple command handlers at once
+     * @param handlers - object mapping command names to handler functions
+     */
+    registerHandlers(handlers: Record<string, (ctx: TelegramExecutionContext) => Promise<Response>>): this;
+    /**
+     * Determine the command from the update
+     * @param ctx - the execution context
+     * @param args - command arguments
+     * @returns the command string
+     */
+    private determineCommand;
+    /**
+     * Parse arguments from the update
+     * @param ctx - the execution context
+     * @returns array of argument strings
+     */
+    private parseArguments;
     /**
      * Handle a request on a given bot
      * @param request - the request to handle

package/dist/telegram_bot.js

@@ -15,13 +15,21 @@ export default class TelegramBot {
     commands = {};
     /** The current bot context */
     currentContext;
+    /** Default command to use when no matching command is found */
+    defaultCommand = ':message';
     /**
      *	Create a bot
      *	@param token - the telegram secret token
+     *	@param options - optional configuration for the bot
      */
-    constructor(token) {
+    constructor(token, options) {
         this.token = token;
         this.api = new URL('https://api.telegram.org/bot' + token);
+        if (options?.defaultCommand) {
+            this.defaultCommand = options.defaultCommand;
+        }
+        // Register default handler for the default command to avoid errors
+        this.commands[this.defaultCommand] = () => Promise.resolve(new Response('Command not implemented'));
     }
     /**
      * Register a function on the bot
@@ -29,11 +37,60 @@ export default class TelegramBot {
      * @param callback - the bot context
      */
     on(event, callback) {
-        if (!['on', 'handle'].includes(event)) {
-            this.commands[event] = callback;
+        this.commands[event] = callback;
+        return this;
+    }
+    /**
+     * Register multiple command handlers at once
+     * @param handlers - object mapping command names to handler functions
+     */
+    registerHandlers(handlers) {
+        for (const [event, callback] of Object.entries(handlers)) {
+            this.on(event, callback);
         }
         return this;
     }
+    /**
+     * Determine the command from the update
+     * @param ctx - the execution context
+     * @param args - command arguments
+     * @returns the command string
+     */
+    determineCommand(ctx, args) {
+        // First check if it's a special update type
+        switch (ctx.update_type) {
+            case 'photo':
+                return ':photo' in this.commands ? ':photo' : this.defaultCommand;
+            case 'document':
+                return ':document' in this.commands ? ':document' : this.defaultCommand;
+            case 'callback':
+                return ':callback' in this.commands ? ':callback' : this.defaultCommand;
+            case 'inline':
+                return ':inline' in this.commands ? ':inline' : this.defaultCommand;
+        }
+        // Then check if it's a command starting with /
+        if (args.at(0)?.startsWith('/')) {
+            const command = args.at(0)?.slice(1) ?? '';
+            return command in this.commands ? command : this.defaultCommand;
+        }
+        return this.defaultCommand;
+    }
+    /**
+     * Parse arguments from the update
+     * @param ctx - the execution context
+     * @returns array of argument strings
+     */
+    parseArguments(ctx) {
+        switch (ctx.update_type) {
+            case 'message':
+            case 'business_message':
+                return this.update.message?.text?.split(' ') ?? [];
+            case 'inline':
+                return this.update.inline_query?.query.split(' ') ?? [];
+            default:
+                return [];
+        }
+    }
     /**
      * Handle a request on a given bot
      * @param request - the request to handle
@@ -41,64 +98,36 @@ export default class TelegramBot {
     async handle(request) {
         this.webhook = new Webhook(this.token, request);
         const url = new URL(request.url);
-        if (`/${this.token}` === url.pathname) {
-            switch (request.method) {
-                case 'POST': {
+        // Check if the request is for this bot
+        if (`/${this.token}` !== url.pathname) {
+            return new Response('Invalid token', { status: 404 });
+        }
+        // Handle different HTTP methods
+        switch (request.method) {
+            case 'POST': {
+                try {
                     this.update = await request.json();
                     console.log(this.update);
-                    let command = ':message';
-                    let args = [];
                     const ctx = new TelegramExecutionContext(this, this.update);
                     this.currentContext = ctx;
-                    switch (ctx.update_type) {
-                        case 'message': {
-                            args = this.update.message?.text?.split(' ') ?? [];
-                            break;
-                        }
-                        case 'business_message': {
-                            args = this.update.message?.text?.split(' ') ?? [];
-                            break;
-                        }
-                        case 'inline': {
-                            args = this.update.inline_query?.query.split(' ') ?? [];
-                            break;
-                        }
-                        case 'photo': {
-                            command = ':photo';
-                            break;
-                        }
-                        case 'document': {
-                            command = ':document';
-                            break;
-                        }
-                        case 'callback': {
-                            command = ':callback';
-                            break;
-                        }
-                        default:
-                            break;
-                    }
-                    if (args.at(0)?.startsWith('/')) {
-                        command = args.at(0)?.slice(1) ?? ':message';
-                    }
-                    if (!(command in this.commands)) {
-                        command = ':message';
-                    }
+                    const args = this.parseArguments(ctx);
+                    const command = this.determineCommand(ctx, args);
                     return await this.commands[command](ctx);
                 }
-                case 'GET': {
-                    switch (url.searchParams.get('command')) {
-                        case 'set':
-                            return this.webhook.set();
-                        default:
-                            break;
-                    }
-                    break;
+                catch (error) {
+                    console.error('Error handling Telegram update:', error);
+                    return new Response('Error processing request', { status: 500 });
+                }
+            }
+            case 'GET': {
+                const command = url.searchParams.get('command');
+                if (command === 'set') {
+                    return this.webhook.set();
                 }
-                default:
-                    break;
+                return new Response('Invalid command', { status: 400 });
             }
+            default:
+                return new Response('Method not allowed', { status: 405 });
         }
-        return new Response('ok');
     }
 }

package/dist/telegram_execution_context.d.ts

@@ -17,15 +17,32 @@ export default class TelegramExecutionContext {
      * @param update - the telegram update
      */
     constructor(bot: TelegramBot, update: TelegramUpdate);
+    /**
+     * Determine the type of update received
+     * @returns The update type as a string
+     */
+    private determineUpdateType;
+    /**
+     * Get the chat ID from the current update
+     * @returns The chat ID as a string or empty string if not available
+     */
+    private getChatId;
+    /**
+     * Get the message ID from the current update
+     * @returns The message ID as a string or empty string if not available
+     */
+    private getMessageId;
     /**
      * Reply to the last message with a video
      * @param video - string to a video on the internet or a file_id on telegram
      * @param options - any additional options to pass to sendVideo
+     * @returns Promise with the API response
      */
-    replyVideo(video: string, options?: Record<string, number | string | boolean>): Promise<Response | undefined>;
+    replyVideo(video: string, options?: Record<string, number | string | boolean>): Promise<Response | null>;
     /**
      * Get File from telegram file_id
      * @param file_id - telegram file_id
+     * @returns Promise with the file response
      */
     getFile(file_id: string): Promise<Response>;
     /**
@@ -33,24 +50,28 @@ export default class TelegramExecutionContext {
      * @param photo - url or file_id to photo
      * @param caption - photo caption
      * @param options - any additional options to pass to sendPhoto
+     * @returns Promise with the API response
      */
-    replyPhoto(photo: string, caption?: string, options?: Record<string, number | string | boolean>): Promise<Response | undefined>;
+    replyPhoto(photo: string, caption?: string, options?: Record<string, number | string | boolean>): Promise<Response | null>;
     /**
      * Send typing in a chat
+     * @returns Promise with the API response
      */
-    sendTyping(): Promise<Response | undefined>;
+    sendTyping(): Promise<Response | null>;
     /**
      * Reply to an inline message with a title and content
      * @param title - title to reply with
      * @param message - message contents to reply with
      * @param parse_mode - parse mode to use
+     * @returns Promise with the API response
      */
-    replyInline(title: string, message: string, parse_mode?: string): Promise<Response | undefined>;
+    replyInline(title: string, message: string, parse_mode?: string): Promise<Response | null>;
     /**
      * Reply to the last message with text
      * @param message - text to reply with
      * @param parse_mode - one of HTML, MarkdownV2, Markdown, or an empty string for ascii
      * @param options - any additional options to pass to sendMessage
+     * @returns Promise with the API response
      */
-    reply(message: string, parse_mode?: string, options?: Record<string, number | string | boolean>): Promise<Response | undefined>;
+    reply(message: string, parse_mode?: string, options?: Record<string, number | string | boolean>): Promise<Response | null>;
 }

package/dist/telegram_execution_context.js

@@ -20,37 +20,66 @@ export default class TelegramExecutionContext {
     constructor(bot, update) {
         this.bot = bot;
         this.update = update;
+        this.update_type = this.determineUpdateType();
+    }
+    /**
+     * Determine the type of update received
+     * @returns The update type as a string
+     */
+    determineUpdateType() {
         if (this.update.message?.photo) {
-            this.update_type = 'photo';
+            return 'photo';
         }
         else if (this.update.message?.text) {
-            this.update_type = 'message';
+            return 'message';
         }
         else if (this.update.inline_query?.query) {
-            this.update_type = 'inline';
+            return 'inline';
         }
         else if (this.update.message?.document) {
-            this.update_type = 'document';
+            return 'document';
         }
         else if (this.update.callback_query?.id) {
-            this.update_type = 'callback';
+            return 'callback';
         }
         else if (this.update.business_message) {
-            this.update_type = 'business_message';
+            return 'business_message';
         }
+        return '';
+    }
+    /**
+     * Get the chat ID from the current update
+     * @returns The chat ID as a string or empty string if not available
+     */
+    getChatId() {
+        if (this.update.message?.chat.id) {
+            return this.update.message.chat.id.toString();
+        }
+        else if (this.update.business_message?.chat.id) {
+            return this.update.business_message.chat.id.toString();
+        }
+        return '';
+    }
+    /**
+     * Get the message ID from the current update
+     * @returns The message ID as a string or empty string if not available
+     */
+    getMessageId() {
+        return this.update.message?.message_id.toString() ?? '';
     }
     /**
      * Reply to the last message with a video
      * @param video - string to a video on the internet or a file_id on telegram
      * @param options - any additional options to pass to sendVideo
+     * @returns Promise with the API response
      */
     async replyVideo(video, options = {}) {
         switch (this.update_type) {
             case 'message':
                 return await this.api.sendVideo(this.bot.api.toString(), {
                     ...options,
-                    chat_id: this.update.message?.chat.id.toString() ?? '',
-                    reply_to_message_id: this.update.message?.message_id.toString() ?? '',
+                    chat_id: this.getChatId(),
+                    reply_to_message_id: this.getMessageId(),
                     video,
                 });
             case 'inline':
@@ -60,12 +89,13 @@ export default class TelegramExecutionContext {
                     results: [new TelegramInlineQueryResultVideo(video)],
                 });
             default:
-                break;
+                return null;
         }
     }
     /**
      * Get File from telegram file_id
      * @param file_id - telegram file_id
+     * @returns Promise with the file response
      */
     async getFile(file_id) {
         return await this.api.getFile(this.bot.api.toString(), { file_id }, this.bot.token);
@@ -75,22 +105,16 @@ export default class TelegramExecutionContext {
      * @param photo - url or file_id to photo
      * @param caption - photo caption
      * @param options - any additional options to pass to sendPhoto
+     * @returns Promise with the API response
      */
     async replyPhoto(photo, caption = '', options = {}) {
         switch (this.update_type) {
             case 'photo':
-                return await this.api.sendPhoto(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.update.message?.chat.id.toString() ?? '',
-                    reply_to_message_id: this.update.message?.message_id.toString() ?? '',
-                    photo,
-                    caption,
-                });
             case 'message':
                 return await this.api.sendPhoto(this.bot.api.toString(), {
                     ...options,
-                    chat_id: this.update.message?.chat.id.toString() ?? '',
-                    reply_to_message_id: this.update.message?.message_id.toString() ?? '',
+                    chat_id: this.getChatId(),
+                    reply_to_message_id: this.getMessageId(),
                     photo,
                     caption,
                 });
@@ -100,27 +124,30 @@ export default class TelegramExecutionContext {
                     results: [new TelegramInlineQueryResultPhoto(photo)],
                 });
             default:
-                break;
+                return null;
         }
     }
     /**
      * Send typing in a chat
+     * @returns Promise with the API response
      */
     async sendTyping() {
         switch (this.update_type) {
             case 'message':
+            case 'photo':
+            case 'document':
                 return await this.api.sendChatAction(this.bot.api.toString(), {
-                    chat_id: this.update.message?.chat.id.toString() ?? '',
+                    chat_id: this.getChatId(),
                     action: 'typing',
                 });
             case 'business_message':
                 return await this.api.sendChatAction(this.bot.api.toString(), {
-                    business_connection_id: this.update.business_message?.business_connection_id.toString(),
-                    chat_id: this.update.business_message?.chat.id.toString() ?? '',
+                    business_connection_id: this.update.business_message?.business_connection_id.toString() ?? '',
+                    chat_id: this.getChatId(),
                     action: 'typing',
                 });
             default:
-                break;
+                return null;
         }
     }
     /**
@@ -128,64 +155,57 @@ export default class TelegramExecutionContext {
      * @param title - title to reply with
      * @param message - message contents to reply with
      * @param parse_mode - parse mode to use
+     * @returns Promise with the API response
      */
     async replyInline(title, message, parse_mode = '') {
-        switch (this.update_type) {
-            case 'inline':
-                return await this.api.answerInline(this.bot.api.toString(), {
-                    inline_query_id: this.update.inline_query?.id.toString() ?? '',
-                    results: [new TelegramInlineQueryResultArticle({ content: message, title, parse_mode })],
-                });
-            default:
-                break;
+        if (this.update_type === 'inline') {
+            return await this.api.answerInline(this.bot.api.toString(), {
+                inline_query_id: this.update.inline_query?.id.toString() ?? '',
+                results: [new TelegramInlineQueryResultArticle({ content: message, title, parse_mode })],
+            });
         }
+        return null;
     }
     /**
      * Reply to the last message with text
      * @param message - text to reply with
      * @param parse_mode - one of HTML, MarkdownV2, Markdown, or an empty string for ascii
      * @param options - any additional options to pass to sendMessage
+     * @returns Promise with the API response
      */
     async reply(message, parse_mode = '', options = {}) {
         switch (this.update_type) {
             case 'message':
+            case 'photo':
+            case 'document':
                 return await this.api.sendMessage(this.bot.api.toString(), {
                     ...options,
-                    chat_id: this.update.message?.chat.id.toString() ?? '',
-                    reply_to_message_id: this.update.message?.message_id.toString() ?? '',
+                    chat_id: this.getChatId(),
+                    reply_to_message_id: this.getMessageId(),
                     text: message,
                     parse_mode,
                 });
             case 'business_message':
                 return await this.api.sendMessage(this.bot.api.toString(), {
-                    chat_id: this.update.business_message?.chat.id.toString() ?? '',
-                    text: message,
-                    business_connection_id: this.update.business_message?.business_connection_id.toString(),
-                    parse_mode,
-                });
-            case 'photo':
-                return await this.api.sendMessage(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.update.message?.chat.id.toString() ?? '',
-                    reply_to_message_id: this.update.message?.message_id.toString() ?? '',
+                    chat_id: this.getChatId(),
                     text: message,
+                    business_connection_id: this.update.business_message?.business_connection_id.toString() ?? '',
                     parse_mode,
                 });
+            case 'callback':
+                if (this.update.callback_query?.message.chat.id) {
+                    return await this.api.sendMessage(this.bot.api.toString(), {
+                        ...options,
+                        chat_id: this.update.callback_query.message.chat.id.toString(),
+                        text: message,
+                        parse_mode,
+                    });
+                }
+                return null;
             case 'inline':
-                return await this.api.answerInline(this.bot.api.toString(), {
-                    inline_query_id: this.update.inline_query?.id.toString() ?? '',
-                    results: [new TelegramInlineQueryResultArticle({ title: message, content: message, parse_mode })],
-                });
-            case 'document':
-                return await this.api.sendMessage(this.bot.api.toString(), {
-                    ...options,
-                    chat_id: this.update.message?.chat.id.toString() ?? '',
-                    reply_to_message_id: this.update.message?.message_id.toString() ?? '',
-                    text: message,
-                    parse_mode,
-                });
+                return await this.replyInline('Response', message, parse_mode);
             default:
-                break;
+                return null;
         }
     }
 }

package/dist/webhook.d.ts

@@ -1,6 +1,31 @@
+/**
+ * Webhook class for managing Telegram bot webhook configuration.
+ * Handles setting up and configuring webhooks for Telegram bots.
+ */
 export default class Webhook {
-    api: URL;
-    webhook: URL;
+    /** Base URL for the Telegram Bot API */
+    private readonly api;
+    /** Webhook URL that Telegram will send updates to */
+    private readonly webhook;
+    /**
+     * Creates a new Webhook instance.
+     *
+     * @param token - The Telegram bot token
+     * @param request - The incoming request object used to determine the webhook URL
+     */
     constructor(token: string, request: Request);
+    /**
+     * Sets the webhook URL for the Telegram bot.
+     *
+     * @returns Promise that resolves to the fetch response from Telegram
+     * @throws Will throw an error if the fetch request fails
+     */
     set(): Promise<Response>;
+    /**
+     * Removes the webhook configuration from Telegram.
+     *
+     * @returns Promise that resolves to the fetch response from Telegram
+     * @throws Will throw an error if the fetch request fails
+     */
+    delete(): Promise<Response>;
 }

package/dist/webhook.js

@@ -1,17 +1,59 @@
+/**
+ * Webhook class for managing Telegram bot webhook configuration.
+ * Handles setting up and configuring webhooks for Telegram bots.
+ */
 export default class Webhook {
+    /** Base URL for the Telegram Bot API */
     api;
+    /** Webhook URL that Telegram will send updates to */
     webhook;
+    /**
+     * Creates a new Webhook instance.
+     *
+     * @param token - The Telegram bot token
+     * @param request - The incoming request object used to determine the webhook URL
+     */
     constructor(token, request) {
-        this.api = new URL('https://api.telegram.org/bot' + token);
-        this.webhook = new URL(new URL(request.url).origin + `/${token}`);
+        this.api = new URL(`https://api.telegram.org/bot${token}`);
+        this.webhook = new URL(`${new URL(request.url).origin}/${token}`);
     }
+    /**
+     * Sets the webhook URL for the Telegram bot.
+     *
+     * @returns Promise that resolves to the fetch response from Telegram
+     * @throws Will throw an error if the fetch request fails
+     */
     async set() {
-        const url = new URL(`${this.api.origin}${this.api.pathname}/setWebhook`);
-        const params = url.searchParams;
-        params.append('url', this.webhook.toString());
-        params.append('max_connections', '100');
-        params.append('allowed_updates', JSON.stringify(['message', 'inline_query', 'business_message', 'business_connection']));
-        params.append('drop_pending_updates', 'true');
-        return await fetch(`${url.toString()}?${params.toString()}`);
+        const url = new URL(`${this.api.toString()}setWebhook`);
+        // Configure webhook parameters
+        const params = new URLSearchParams({
+            url: this.webhook.toString(),
+            max_connections: '100',
+            allowed_updates: JSON.stringify(['message', 'inline_query', 'business_message', 'business_connection']),
+            drop_pending_updates: 'true',
+        });
+        try {
+            return await fetch(`${url.toString()}?${params.toString()}`);
+        }
+        catch (error) {
+            console.error('Failed to set webhook:', error);
+            throw error;
+        }
+    }
+    /**
+     * Removes the webhook configuration from Telegram.
+     *
+     * @returns Promise that resolves to the fetch response from Telegram
+     * @throws Will throw an error if the fetch request fails
+     */
+    async delete() {
+        const url = new URL(`${this.api.toString()}deleteWebhook`);
+        try {
+            return await fetch(url.toString());
+        }
+        catch (error) {
+            console.error('Failed to delete webhook:', error);
+            throw error;
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@codebam/cf-workers-telegram-bot",
-	"version": "8.1.1",
+	"version": "9.0.0",
 	"description": "serverless telegram bot on cf workers",
 	"main": "./dist/main.js",
 	"module": "./dist/main.js",
@@ -31,16 +31,16 @@
 		"url": "https://github.com/codebam/cf-workers-telegram-bot.git"
 	},
 	"devDependencies": {
-		"@cloudflare/workers-types": "^4.20241202.0",
-		"@eslint/js": "^9.16.0",
-		"@typescript-eslint/eslint-plugin": "^8.17.0",
-		"@typescript-eslint/parser": "^8.17.0",
-		"eslint": "^9.16.0",
-		"eslint-config-prettier": "^9.1.0",
-		"globals": "^15.13.0",
+		"@cloudflare/workers-types": "^4.20250121.0",
+		"@eslint/js": "^9.18.0",
+		"@typescript-eslint/eslint-plugin": "^8.21.0",
+		"@typescript-eslint/parser": "^8.21.0",
+		"eslint": "^9.18.0",
+		"eslint-config-prettier": "^10.0.1",
+		"globals": "^15.14.0",
 		"prettier": "^3.4.2",
-		"typescript": "^5.7.2",
-		"typescript-eslint": "^8.17.0",
-		"vitest": "^2.1.8"
+		"typescript": "^5.7.3",
+		"typescript-eslint": "^8.21.0",
+		"vitest": "^3.0.2"
 	}
 }