@skroz/telegram-bot 1.0.28 → 1.1.0

package/src/index_backup.ts

@@ -0,0 +1,430 @@
+const indexBackup = {};
+export default indexBackup;
+/*
+import TelegramApi from '@skroz/telegram-api';
+import {
+  TG_BotCommand,
+  TG_CallbackQuery,
+  TG_ChatResponse,
+  TG_DeleteMessageInput,
+  TG_Message,
+  TG_PreCheckoutQuery,
+  TG_SendActionInput,
+  TG_SendMessageInput,
+  TG_SendMessageResponse,
+  TG_SendPhotoInput,
+  TG_SetMyCommandsResponse,
+  TG_SuccessfulPayment,
+  TG_Update,
+} from '@skroz/telegram-api/dist/TelegramTypes';
+
+/!* eslint-disable @typescript-eslint/naming-convention *!/
+
+/!* хранит уникальные колбэки, чтобы исключить повторное нажатие *!/
+const processedCallbacks = new Set();
+/!* разделитель для параметров колбэка *!/
+const callbackDivider = '^:^:^';
+/!* по умолчанию истекающее сообщение *!/
+const expiresSecondsDefault = 5 * 60; // 5 минут
+
+/!* не больше 64 символов по документации, внутри защита от повторных кликов *!/
+export const createCallbackData = (
+  telegramId: number | string,
+  data: (string | number)[]
+): string =>
+  [`${Date.now()}_${telegramId}`, ...data].join(callbackDivider).slice(0, 64);
+
+/!* не больше 64 символов по документации, внутри защита от повторных кликов *!/
+export const getCallbackData = (data: string): string[] =>
+  data.split(callbackDivider).slice(1);
+
+const expiredMessagesList: {
+  message: TG_Message;
+  // user: TG_User;
+  expiresAt: number;
+  onExpire: (message: TG_Message) => void;
+}[] = [];
+
+const pushMessageToExpireList = (
+  message: TG_Message,
+  // user: TG_User,
+  expires: ExpiresInput
+) => {
+  const expiresAt =
+    Date.now() + (expires.seconds || expiresSecondsDefault) * 1000;
+
+  expiredMessagesList.push({
+    message,
+    // user,
+    expiresAt,
+    onExpire: expires.onExpire,
+  });
+};
+
+// забирает и сразу удаляет
+const shiftExpiredMessages = (): {
+  message: TG_Message;
+  // user: TG_User;
+  // from: TG_User;
+  onExpire: (
+    message: TG_Message
+    // , user: TG_User
+  ) => void;
+}[] => {
+  const now = Date.now();
+  const expired = expiredMessagesList.filter((msg) => msg.expiresAt <= now);
+  expiredMessagesList.splice(0, expired.length);
+  return expired;
+};
+
+// убираем из списка удаленные сообщения
+const deleteMessageFromExpiringList = (message: TG_Message) => {
+  const index = expiredMessagesList.findIndex(
+    (msg) => msg.message.message_id === message.message_id
+  );
+  if (index !== -1) {
+    expiredMessagesList.splice(index, 1);
+  }
+};
+
+/!* обрабатываем истекшие сообщения по таймеру *!/
+setInterval(async () => {
+  const expired = shiftExpiredMessages();
+  if (expired.length > 0) {
+    await Promise.all(
+      expired.map(async (ex) => {
+        await ex.onExpire(ex.message);
+      })
+    );
+  }
+}, 15000);
+
+type ExpiresInput = {
+  seconds?: number;
+  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 ?? {}),
+    }; *!/
+  }
+
+  // публичный контейнер
+  /!* readonly messages: {
+    text: Record<
+      string,
+      {
+        send: (
+          input: TG_SendMessageInput,
+          message?: TG_Message,
+          onExpire?: (resultMessage: TG_Message) => void
+        ) => Promise<TG_SendMessageResponse>;
+      }
+    >;
+    photo: Record<
+      string,
+      {
+        send: (
+          input: TG_SendPhotoInput,
+          message?: TG_Message,
+          onExpire?: (resultMessage: TG_Message) => void
+        ) => Promise<TG_SendMessageResponse>;
+      }
+    >;
+  }; *!/
+
+  async handleUpdate(
+    update: TG_Update,
+    handleCallback: (
+      callbackQuery: TG_CallbackQuery,
+      callbackDataParams: string[]
+    ) => Promise<void>,
+    handleMessage: (message: TG_Message) => void,
+    handlePreCheckoutQuery: (
+      preCheckoutQuery: TG_PreCheckoutQuery
+    ) => Promise<{ ok: boolean; error_message?: string }>,
+    handleSuccessfulPayment: (
+      successfulPayment: TG_SuccessfulPayment,
+      message: TG_Message
+    ) => Promise<void>
+  ): Promise<void> {
+    const callbackQuery = update.callback_query;
+    if (callbackQuery) {
+      const { data } = callbackQuery;
+
+      if (!data) {
+        // 1. Коллбэк пришел от WebApp
+        // 2. Игровая кнопка
+        // 3. Кнопка с удаленным сообщением
+        return; // todo sendError
+      }
+
+      // data - всегда уникален, потому что в начале стоит текущий Date.now()
+      if (processedCallbacks.has(data)) {
+        // чтобы избежать дублирования нажатия на кнопку
+        return; // Уже обработан
+      }
+      processedCallbacks.add(data);
+
+      // Удаляем из памяти через 60 секунд
+      setTimeout(() => {
+        processedCallbacks.delete(data);
+      }, 60 * 1000);
+
+      await handleCallback(callbackQuery, getCallbackData(data));
+    }
+    /!* Часть оплаты *!/
+    const preCheckoutQuery = update.pre_checkout_query;
+    if (preCheckoutQuery) {
+      /!* Нужно ответить в течение 10 секунд внутри метода или заказ отменяется автоматически *!/
+      const { ok, error_message } = await handlePreCheckoutQuery(
+        preCheckoutQuery
+      );
+
+      await TelegramApi.answerPreCheckoutQuery(
+        {
+          pre_checkout_query_id: preCheckoutQuery.id,
+          ok,
+          error_message,
+        },
+        this.botToken
+      );
+      return;
+    }
+
+    /!* обработаем сообщение *!/
+    const { message } = update; // его нет, если это нажатие на кнопку callback_query или при редактировании предыдущего сообщения
+
+    if (message) {
+      const { successful_payment } = message;
+      if (successful_payment) {
+        /!* Успешная оплата *!/
+        await handleSuccessfulPayment(successful_payment, message);
+        return;
+      }
+
+      if (!callbackQuery) {
+        /!* разбираем входящий текст *!/
+        await handleMessage(message);
+      }
+    }
+  }
+
+  async sendPhoto(
+    input: TG_SendPhotoInput,
+    message?: TG_Message,
+    onExpire?: (resultMessage: TG_Message) => void
+  ): Promise<TG_SendMessageResponse> {
+    let sendResult: TG_SendMessageResponse;
+
+    const sendPhotoFunction = () =>
+      TelegramApi.sendPhoto(
+        {
+          protect_content: this.protect_content, // переписывается инпутом
+          parse_mode: 'HTML',
+          ...input,
+        },
+        this.botToken
+      );
+
+    if (message) {
+      try {
+        sendResult = await TelegramApi.editMessageMedia(
+          {
+            media: {
+              type: 'photo',
+              media: input.photo as string,
+              caption: input.caption,
+              parse_mode: 'HTML',
+            },
+            ...input,
+            message_id: message.message_id,
+          },
+          this.botToken
+        );
+      } catch (e) {
+        sendResult = await sendPhotoFunction();
+      }
+    } else {
+      sendResult = await sendPhotoFunction();
+    }
+
+    if (sendResult.ok && sendResult.result) {
+      if (onExpire) {
+        pushMessageToExpireList(sendResult.result, {
+          seconds: this.expiresMessageSeconds,
+          onExpire,
+        });
+      } else {
+        deleteMessageFromExpiringList(sendResult.result);
+      }
+    }
+
+    return sendResult;
+  }
+
+  async sendMessage(
+    input: TG_SendMessageInput,
+    message?: TG_Message,
+    onExpire?: (resultMessage: TG_Message) => void
+  ): Promise<TG_SendMessageResponse> {
+    let sendResult: TG_SendMessageResponse;
+
+    const sendPhotoFunction = () =>
+      TelegramApi.sendMessage(
+        {
+          parse_mode: 'HTML',
+          protect_content: this.protect_content, // переписывается инпутом
+          ...input,
+        },
+        this.botToken
+      );
+
+    if (message) {
+      try {
+        sendResult = await TelegramApi.editMessageText(
+          {
+            message_id: message.message_id,
+            ...input,
+          },
+          this.botToken
+        );
+      } catch (e) {
+        sendResult = await sendPhotoFunction();
+      }
+    } else {
+      sendResult = await sendPhotoFunction();
+    }
+
+    if (sendResult.ok && sendResult.result) {
+      if (onExpire) {
+        pushMessageToExpireList(sendResult.result, {
+          seconds: this.expiresMessageSeconds,
+          onExpire,
+        });
+      } else {
+        deleteMessageFromExpiringList(sendResult.result);
+      }
+    }
+
+    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);
+  }
+
+  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;
+*/