@skroz/telegram-bot 1.0.29 → 1.1.1

package/src/index.ts

@@ -1,22 +1,38 @@
-import TelegramApi from '@skroz/telegram-api';
+export * from './TelegramTypes';
 import {
+  TG_AnswerPreCheckoutQueryInput,
+  TG_AnswerPreCheckoutQueryResponse,
   TG_BotCommand,
   TG_CallbackQuery,
   TG_ChatResponse,
+  TG_CreateInvoiceInput,
   TG_DeleteMessageInput,
+  TG_EditMessageCaptionInput,
+  TG_EditMessageMediaInput,
+  TG_EditMessageTextInput,
+  TG_GetFileResponse,
+  TG_GetMeResponse,
+  TG_GetUpdatesResponse,
   TG_Message,
   TG_PreCheckoutQuery,
   TG_SendActionInput,
+  TG_SendMediaGroupInput,
+  TG_SendMediaGroupResponse,
   TG_SendMessageInput,
   TG_SendMessageResponse,
   TG_SendPhotoInput,
+  TG_SendVideoInput,
   TG_SetMyCommandsResponse,
   TG_SuccessfulPayment,
   TG_Update,
-} from '@skroz/telegram-api/dist/TelegramTypes';
+} from './TelegramTypes';
+import ResultAndDescription from './ResultAndDescription';
 
 /* eslint-disable @typescript-eslint/naming-convention */
 
+const TELEGRAM_MAX_TEXT_LENGTH = 4096; // Максимальная длина текста в телеграм сообщении
+const TELEGRAM_MAX_CAPTION_LENGTH = 1024;
+
 /* хранит уникальные колбэки, чтобы исключить повторное нажатие */
 const processedCallbacks = new Set();
 /* разделитель для параметров колбэка */
@@ -101,64 +117,211 @@ type ExpiresInput = {
   onExpire: (resultMessage: TG_Message) => void;
 };
 
-/* Тип функции отправки в телеграм */
-/* type TelegramSendFunction<TInput, TResponse> = (
-  input: TInput
-) => Promise<TResponse>; */
-
-/* Тип типов функций отправки */
-/* type TG_SendFunction =
-  | TelegramSendFunction<TG_SendMessageInput, TG_SendMessageResponse>
-  | TelegramSendFunction<TG_SendPhotoInput, TG_SendMessageResponse>; */
-// в будущем:
-// | TelegramSendFunction<TG_SendDocumentInput, TG_SendDocumentResponse>
-
-// interface TelegramMessageHandler<TInput, TResponse> {
-//   send: (input: TInput) => Promise<TResponse>;
-// }
-
 class TelegramBot {
   constructor(
     private readonly botToken: string,
-    /* messages: {
-      text?: Record<
-        string,
-        (input: TG_SendMessageInput) => TG_SendMessageInput
-      >;
-      photo?: Record<string, (input: TG_SendPhotoInput) => TG_SendPhotoInput>;
-    }, */
     private readonly expiresMessageSeconds?: number,
     private readonly protect_content?: boolean
-  ) {
-    /* this.messages = {
-      text: this.wrapTextMessages(messages.text ?? {}),
-      photo: this.wrapPhotoMessages(messages.photo ?? {}),
-    }; */
+  ) { }
+
+  /* Отправка данных в Телеграм */
+  private async request<T extends { ok: boolean; description?: string }>(
+    method: string,
+    options: {
+      method?: 'GET' | 'POST';
+      body?: any;
+      queryParams?: Record<string, any>;
+    } = {}
+  ): Promise<T> {
+    let url = `https://api.telegram.org/bot${this.botToken}/${method}`;
+    if (options.queryParams) {
+      const params = new URLSearchParams();
+      Object.keys(options.queryParams).forEach((key) => {
+        const value = options.queryParams![key];
+        if (value !== undefined) {
+          params.append(key, String(value));
+        }
+      });
+      url += `?${params.toString()}`;
+    }
+
+    const fetchOptions: any = {
+      method: options.method || 'POST',
+    };
+
+    if (options.body) {
+      fetchOptions.headers = {
+        'Content-Type': 'application/json',
+      };
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+
+    try {
+      const response = await fetch(url, fetchOptions);
+      const data = await response.json();
+      return data as T;
+    } catch (error: any) {
+      // console.error(`Error in ${method}:`, error.message);
+      return {
+        ok: false,
+        description: `Request failed: ${error.message}`,
+      } as unknown as T;
+    }
+  }
+
+  async editMessageText(
+    input: TG_EditMessageTextInput
+  ): Promise<TG_SendMessageResponse> {
+    if (input.text && input.text.length > TELEGRAM_MAX_TEXT_LENGTH)
+      throw new Error(
+        `Текст сообщения не может превышать ${TELEGRAM_MAX_TEXT_LENGTH} символов`
+      );
+
+    return this.request<TG_SendMessageResponse>('editMessageText', {
+      body: input,
+    });
+  }
+
+  async editMessageCaption(
+    input: TG_EditMessageCaptionInput
+  ): Promise<TG_SendMessageResponse> {
+    if (input.caption && input.caption.length > TELEGRAM_MAX_CAPTION_LENGTH)
+      throw new Error(
+        `Подпись не может превышать ${TELEGRAM_MAX_CAPTION_LENGTH} символов`
+      );
+
+    return this.request<TG_SendMessageResponse>('editMessageCaption', {
+      body: input,
+    });
+  }
+
+  async sendVideo(input: TG_SendVideoInput): Promise<TG_SendMessageResponse> {
+    if (input.caption && input.caption.length > TELEGRAM_MAX_CAPTION_LENGTH)
+      throw new Error(
+        `Текст рядом с видео по правилам Телеграм не может превышать ${TELEGRAM_MAX_CAPTION_LENGTH} символов`
+      );
+
+    return this.request<TG_SendMessageResponse>('sendVideo', {
+      body: input,
+    });
   }
 
-  // публичный контейнер
-  /* readonly messages: {
-    text: Record<
-      string,
+  async editMessageMedia(
+    input: TG_EditMessageMediaInput
+  ): Promise<TG_SendMessageResponse> {
+    return this.request<TG_SendMessageResponse>('editMessageMedia', {
+      body: input,
+    });
+  }
+
+  async sendMediaGroup(
+    input: TG_SendMediaGroupInput
+  ): Promise<TG_SendMediaGroupResponse> {
+    if (input.media.length < 2)
+      throw new Error('Минимум 2 фото для метода sendMediaGroup');
+
+    const { caption } = input.media[0];
+    if (caption && caption.length > TELEGRAM_MAX_CAPTION_LENGTH)
+      throw new Error(
+        `Текст рядом с фото по правилам Телеграм не может превышать ${TELEGRAM_MAX_CAPTION_LENGTH} символов`
+      );
+
+    return this.request<TG_SendMediaGroupResponse>('sendMediaGroup', {
+      body: input,
+    });
+  }
+
+  async getMe(): Promise<TG_GetMeResponse> {
+    return this.request<TG_GetMeResponse>('getMe', {
+      method: 'GET',
+    });
+  }
+
+  async setWebhook(webhookUrl: string): Promise<ResultAndDescription> {
+    return this.request<ResultAndDescription>('setWebhook', {
+      method: 'POST',
+      queryParams: { url: webhookUrl },
+    });
+  }
+
+  async setMyCommands(
+    commands: TG_BotCommand[]
+  ): Promise<TG_SetMyCommandsResponse> {
+    return this.request<TG_SetMyCommandsResponse>('setMyCommands', {
+      body: { commands },
+    });
+  }
+
+  async getUpdates(offset?: number): Promise<TG_GetUpdatesResponse> {
+    return this.request<TG_GetUpdatesResponse>('getUpdates', {
+      method: 'GET',
+      queryParams: offset ? { offset } : undefined,
+    });
+  }
+
+  async deleteWebhook(): Promise<void> {
+    const data = await this.request<{ ok: boolean; description?: string }>(
+      'deleteWebhook',
       {
-        send: (
-          input: TG_SendMessageInput,
-          message?: TG_Message,
-          onExpire?: (resultMessage: TG_Message) => void
-        ) => Promise<TG_SendMessageResponse>;
+        method: 'GET',
       }
-    >;
-    photo: Record<
-      string,
+    );
+    if (data.ok) {
+      console.log('Вебхук успешно удален');
+    } else {
+      console.error('Ошибка при удалении вебхука:', data.description);
+    }
+  }
+
+  async sendChatAction(input: TG_SendActionInput): Promise<boolean> {
+    const data = await this.request<{ ok: boolean }>('sendChatAction', {
+      body: input,
+    });
+    return data.ok;
+  }
+
+  async getChat(chatId: string | number): Promise<TG_ChatResponse> {
+    return this.request<TG_ChatResponse>('getChat', {
+      body: { chat_id: chatId },
+    });
+  }
+
+  async getFile(fileId: string): Promise<TG_GetFileResponse> {
+    const data = await this.request<TG_GetFileResponse>('getFile', {
+      method: 'GET',
+      queryParams: { file_id: fileId },
+    });
+    if (!data.ok) {
+      throw new Error(`Failed to fetch file: ${data.description}`);
+    }
+    return data;
+  }
+
+  async deleteMessage(input: TG_DeleteMessageInput): Promise<boolean> {
+    const data = await this.request<{ ok: boolean }>('deleteMessage', {
+      body: input,
+    });
+    return data.ok;
+  }
+
+  async createInvoiceLink(
+    input: TG_CreateInvoiceInput
+  ): Promise<{ ok: boolean; result: string }> {
+    return this.request<{ ok: boolean; result: string }>('createInvoiceLink', {
+      body: input,
+    });
+  }
+
+  async answerPreCheckoutQuery(
+    input: TG_AnswerPreCheckoutQueryInput
+  ): Promise<TG_AnswerPreCheckoutQueryResponse> {
+    return this.request<TG_AnswerPreCheckoutQueryResponse>(
+      'answerPreCheckoutQuery',
       {
-        send: (
-          input: TG_SendPhotoInput,
-          message?: TG_Message,
-          onExpire?: (resultMessage: TG_Message) => void
-        ) => Promise<TG_SendMessageResponse>;
+        body: input,
       }
-    >;
-  }; */
+    );
+  }
 
   async handleUpdate(
     update: TG_Update,
@@ -208,14 +371,11 @@ class TelegramBot {
         preCheckoutQuery
       );
 
-      await TelegramApi.answerPreCheckoutQuery(
-        {
-          pre_checkout_query_id: preCheckoutQuery.id,
-          ok,
-          error_message,
-        },
-        this.botToken
-      );
+      await this.answerPreCheckoutQuery({
+        pre_checkout_query_id: preCheckoutQuery.id,
+        ok,
+        error_message,
+      });
       return;
     }
 
@@ -245,29 +405,30 @@ class TelegramBot {
     let sendResult: TG_SendMessageResponse;
 
     const sendPhotoFunction = () =>
-      TelegramApi.sendPhoto(
-        {
+      this.request<TG_SendMessageResponse>('sendPhoto', {
+        body: {
           protect_content: this.protect_content, // переписывается инпутом
           parse_mode: 'HTML',
           ...input,
         },
-        this.botToken
-      );
+      });
 
     if (message) {
       try {
-        sendResult = await TelegramApi.editMessageMedia(
+        sendResult = await this.request<TG_SendMessageResponse>(
+          'editMessageMedia',
           {
-            media: {
-              type: 'photo',
-              media: input.photo as string,
-              caption: input.caption,
-              parse_mode: 'HTML',
+            body: {
+              media: {
+                type: 'photo',
+                media: input.photo as string,
+                caption: input.caption,
+                parse_mode: 'HTML',
+              },
+              ...input,
+              message_id: message.message_id,
             },
-            ...input,
-            message_id: message.message_id,
-          },
-          this.botToken
+          }
         );
       } catch (e) {
         sendResult = await sendPhotoFunction();
@@ -295,26 +456,30 @@ class TelegramBot {
     message?: TG_Message,
     onExpire?: (resultMessage: TG_Message) => void
   ): Promise<TG_SendMessageResponse> {
+    if (input.text.length > TELEGRAM_MAX_TEXT_LENGTH)
+      throw new Error(`Текст превышает ${TELEGRAM_MAX_TEXT_LENGTH} символов`);
+
     let sendResult: TG_SendMessageResponse;
 
     const sendPhotoFunction = () =>
-      TelegramApi.sendMessage(
-        {
+      this.request<TG_SendMessageResponse>('sendMessage', {
+        body: {
           parse_mode: 'HTML',
           protect_content: this.protect_content, // переписывается инпутом
           ...input,
         },
-        this.botToken
-      );
+      });
 
     if (message) {
       try {
-        sendResult = await TelegramApi.editMessageText(
+        sendResult = await this.request<TG_SendMessageResponse>(
+          'editMessageText',
           {
-            message_id: message.message_id,
-            ...input,
-          },
-          this.botToken
+            body: {
+              message_id: message.message_id,
+              ...input,
+            },
+          }
         );
       } catch (e) {
         sendResult = await sendPhotoFunction();
@@ -337,90 +502,9 @@ class TelegramBot {
     return sendResult;
   }
 
-  async getUpdates(offset?: number) {
-    return TelegramApi.getUpdates(this.botToken, offset);
-  }
-
-  async setWebhook(webhookUrl: string) {
-    return TelegramApi.setWebhook(this.botToken, webhookUrl);
-  }
-
-  async deleteWebhook() {
-    return TelegramApi.deleteWebhook(this.botToken);
-  }
-
-  async setMyCommands(
-    commands: TG_BotCommand[]
-  ): Promise<TG_SetMyCommandsResponse> {
-    return TelegramApi.setMyCommands(commands, this.botToken);
-  }
-
   async getChatInfo(telegramId: string | number): Promise<TG_ChatResponse> {
-    return TelegramApi.getChat(telegramId, this.botToken);
-  }
-
-  async sendChatAction(input: TG_SendActionInput): Promise<boolean> {
-    return TelegramApi.sendChatAction(input, this.botToken);
+    return this.getChat(telegramId);
   }
-
-  async deleteMessage(input: TG_DeleteMessageInput): Promise<boolean> {
-    return TelegramApi.deleteMessage(input, this.botToken);
-  }
-
-  // генераторы типовых методов
-  /* private wrapTextMessages(
-    defs: Record<string, (input: TG_SendMessageInput) => TG_SendMessageInput>
-  ) {
-    const result: Record<
-      string,
-      {
-        send: (
-          input: TG_SendMessageInput,
-          message?: TG_Message,
-          onExpire?: (m: TG_Message) => void
-        ) => Promise<TG_SendMessageResponse>;
-      }
-    > = {};
-
-    Object.entries(defs).forEach(([key, builder]) => {
-      result[key] = {
-        send: (input, message, onExpire) =>
-          this.sendMessage(
-            builder(input ?? ({} as TG_SendMessageInput)),
-            message,
-            onExpire
-          ),
-      };
-    });
-    return result;
-  }
-
-  private wrapPhotoMessages(
-    defs: Record<string, (input: TG_SendPhotoInput) => TG_SendPhotoInput>
-  ) {
-    const result: Record<
-      string,
-      {
-        send: (
-          input: TG_SendPhotoInput,
-          message?: TG_Message,
-          onExpire?: (m: TG_Message) => void
-        ) => Promise<TG_SendMessageResponse>;
-      }
-    > = {};
-
-    Object.entries(defs).forEach(([key, builder]) => {
-      result[key] = {
-        send: (input, message, onExpire) =>
-          this.sendPhoto(
-            builder(input ?? ({} as TG_SendPhotoInput)),
-            message,
-            onExpire
-          ),
-      };
-    });
-    return result;
-  } */
 }
 
 export default TelegramBot;