chz-telegram-bot 0.0.15 → 0.0.17

package/services/telegramApi.ts

@@ -1,38 +1,39 @@
-import MessageContext from '../entities/context/messageContext';
-import ChatContext from '../entities/context/chatContext';
-import ImageMessage from '../entities/responses/imageMessage';
-import TextMessage from '../entities/responses/textMessage';
-import VideoMessage from '../entities/responses/videoMessage';
-import taskScheduler from './taskScheduler';
-import logger from './logger';
-import { Telegraf } from 'telegraf';
-import IReplyMessage from '../types/replyMessage';
-import IncomingMessage from '../entities/incomingMessage';
-import { Milliseconds } from '../types/timeValues';
-import Reaction from '../entities/responses/reaction';
-import { InputFile } from 'telegraf/types';
+import { InputFile, Message } from 'telegraf/types';
+import { ChatContext } from '../entities/context/chatContext';
+import { MessageContext } from '../entities/context/messageContext';
 import { reverseMap } from '../helpers/reverseMap';
 import { IStorageClient } from '../types/storage';
-
-export default class TelegramApiService {
+import { Milliseconds } from '../types/timeValues';
+import { Scheduler } from './taskScheduler';
+import { Logger } from './logger';
+import { Reaction } from '../entities/responses/reaction';
+import { IncomingMessage } from '../entities/incomingMessage';
+import { BotResponse, IReplyMessage } from '../types/response';
+import { UnpinResponse } from '../entities/responses/unpin';
+import { TextMessage } from '../entities/responses/textMessage';
+import { VideoMessage } from '../entities/responses/videoMessage';
+import { ImageMessage } from '../entities/responses/imageMessage';
+import { Telegram } from 'telegraf/typings/telegram';
+
+export class TelegramApiService {
     botName: string;
-    telegraf: Telegraf;
+    telegram: Telegram;
     chats: Map<number, string>;
-    messageQueue: Array<IReplyMessage<unknown> | Reaction> = [];
+    messageQueue: Array<BotResponse> = [];
     storage: IStorageClient;
 
     constructor(
         botName: string,
-        telegraf: Telegraf,
+        telegram: Telegram,
         storage: IStorageClient,
         chats: Map<string, number>
     ) {
-        this.telegraf = telegraf;
+        this.telegram = telegram;
         this.botName = botName;
         this.chats = reverseMap(chats);
         this.storage = storage;
 
-        taskScheduler.createTask(
+        Scheduler.createTask(
             'MessageSending',
             () => {
                 this.dequeueResponse();
@@ -51,7 +52,7 @@ export default class TelegramApiService {
         try {
             await this.processResponse(message);
         } catch (error) {
-            logger.errorWithTraceId(
+            Logger.errorWithTraceId(
                 this.botName,
                 message.traceId,
                 this.chats.get(message.chatId)!,
@@ -61,28 +62,33 @@ export default class TelegramApiService {
         }
     }
 
-    private async processResponse<TType>(
-        response: IReplyMessage<TType> | Reaction
+    private async pinIfShould<T>(
+        response: IReplyMessage<T>,
+        sentMessage: Message
     ) {
-        if ('emoji' in response) {
-            this.telegraf.telegram.setMessageReaction(
+        if (response.shouldPin) {
+            await this.telegram.pinChatMessage(
                 response.chatId,
-                response.messageId,
-                [
-                    {
-                        type: 'emoji',
-                        emoji: response.emoji
-                    }
-                ],
-                true
+                sentMessage.message_id,
+                { disable_notification: true }
             );
 
-            return;
+            await this.storage.updateStateFor(
+                response.sourceActionKey,
+                response.chatId,
+                async (state) => {
+                    state.pinnedMessages.push(sentMessage.message_id);
+                }
+            );
         }
+    }
+
+    private async processResponse(response: BotResponse) {
+        let sentMessage: Message;
 
-        switch (response.constructor) {
-            case TextMessage:
-                await this.telegraf.telegram.sendMessage(
+        switch (response.kind) {
+            case 'text':
+                sentMessage = await this.telegram.sendMessage(
                     response.chatId,
                     response.content as string,
                     {
@@ -92,9 +98,11 @@ export default class TelegramApiService {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     } as any
                 );
+
+                await this.pinIfShould(response, sentMessage);
                 break;
-            case ImageMessage:
-                await this.telegraf.telegram.sendPhoto(
+            case 'image':
+                sentMessage = await this.telegram.sendPhoto(
                     response.chatId,
                     response.content as InputFile,
                     response.replyId
@@ -102,9 +110,11 @@ export default class TelegramApiService {
                           ({ reply_to_message_id: response.replyId } as any)
                         : undefined
                 );
+
+                await this.pinIfShould(response, sentMessage);
                 break;
-            case VideoMessage:
-                await this.telegraf.telegram.sendVideo(
+            case 'video':
+                sentMessage = await this.telegram.sendVideo(
                     response.chatId,
                     response.content as InputFile,
                     response.replyId
@@ -112,35 +122,58 @@ export default class TelegramApiService {
                           ({ reply_to_message_id: response.replyId } as any)
                         : undefined
                 );
+
+                await this.pinIfShould(response, sentMessage);
                 break;
-            default:
-                logger.errorWithTraceId(
-                    this.botName,
-                    response.traceId,
-                    this.chats.get(response.chatId)!,
-                    `Unknown message type: ${response.constructor}`,
-                    response
+            case 'react':
+                await this.telegram.setMessageReaction(
+                    response.chatId,
+                    response.messageId,
+                    [
+                        {
+                            type: 'emoji',
+                            emoji: response.emoji
+                        }
+                    ],
+                    true
+                );
+
+                return;
+            case 'unpin':
+                await this.telegram.unpinChatMessage(
+                    response.chatId,
+                    response.messageId
+                );
+
+                await this.storage.updateStateFor(
+                    response.sourceActionKey,
+                    response.chatId,
+                    async (state) => {
+                        state.pinnedMessages = state.pinnedMessages.filter(
+                            (x) => x != response.messageId
+                        );
+                    }
                 );
                 break;
         }
     }
 
-    private enqueueResponse<TType>(response: IReplyMessage<TType>) {
-        this.messageQueue.push(response);
-    }
-
-    private enqueueReaction(reaction: Reaction) {
+    private enqueue(reaction: BotResponse) {
         this.messageQueue.push(reaction);
     }
 
     private getInteractions() {
         return {
-            react: (reaction) => this.enqueueReaction(reaction),
-            respond: (response) => this.enqueueResponse(response)
+            react: (reaction) => this.enqueue(reaction),
+            respond: (response) => this.enqueue(response),
+            unpin: (unpinMessage) => this.enqueue(unpinMessage)
         } as IBotApiInteractions;
     }
 
-    createContextForMessage(incomingMessage: IncomingMessage) {
+    createContextForMessage(
+        incomingMessage: IncomingMessage,
+        commandKey: string
+    ) {
         const firstName = incomingMessage.from?.first_name ?? 'Unknown user';
         const lastName = incomingMessage.from?.last_name
             ? ` ${incomingMessage.from?.last_name}`
@@ -148,6 +181,7 @@ export default class TelegramApiService {
 
         return new MessageContext(
             this.botName,
+            commandKey,
             this.getInteractions(),
             incomingMessage.chat.id,
             incomingMessage.chatName,
@@ -160,19 +194,21 @@ export default class TelegramApiService {
         );
     }
 
-    createContextForChat(chatId: number, scheduledName: string) {
+    createContextForChat(chatId: number, scheduledKey: string) {
         return new ChatContext(
             this.botName,
+            scheduledKey,
             this.getInteractions(),
             chatId,
             this.chats.get(chatId)!,
-            `Scheduled:${scheduledName}:${chatId}`,
+            `Scheduled:${scheduledKey}:${chatId}`,
             this.storage
         );
     }
 }
 
 export interface IBotApiInteractions {
-    respond: <TType>(response: IReplyMessage<TType>) => void;
+    respond: (response: TextMessage | VideoMessage | ImageMessage) => void;
     react: (reaction: Reaction) => void;
+    unpin: (unpinMessage: UnpinResponse) => void;
 }

package/types/actionState.ts

@@ -1,3 +1,4 @@
-export default interface IActionState {
+export interface IActionState {
     lastExecutedDate: number;
+    pinnedMessages: number[];
 }

package/types/actionWithState.ts

@@ -1,6 +1,6 @@
-import IActionState from './actionState';
+import { IActionState } from './actionState';
 
-export default interface IActionWithState {
+export interface IActionWithState {
     key: string;
     stateConstructor: () => IActionState;
 }

package/types/commandCondition.ts

@@ -1,5 +1,5 @@
-import MessageContext from '../entities/context/messageContext';
-import IActionState from './actionState';
+import { MessageContext } from '../entities/context/messageContext';
+import { IActionState } from './actionState';
 
 export type CommandCondition<TActionState extends IActionState> = (
     ctx: MessageContext<TActionState>

package/types/handlers.ts

@@ -1,6 +1,6 @@
-import ChatContext from '../entities/context/chatContext';
-import MessageContext from '../entities/context/messageContext';
-import IActionState from './actionState';
+import { ChatContext } from '../entities/context/chatContext';
+import { MessageContext } from '../entities/context/messageContext';
+import { IActionState } from './actionState';
 import { CachedValueAccessor } from './cachedValueAccessor';
 
 export type CommandHandler<TActionState extends IActionState> = (

package/types/response.ts

@@ -0,0 +1,34 @@
+import { ImageMessage } from '../entities/responses/imageMessage';
+import { Reaction } from '../entities/responses/reaction';
+import { TextMessage } from '../entities/responses/textMessage';
+import { UnpinResponse } from '../entities/responses/unpin';
+import { VideoMessage } from '../entities/responses/videoMessage';
+
+export const BotResponseTypes = {
+    unpin: 'unpin',
+    text: 'text',
+    image: 'image',
+    video: 'video',
+    react: 'react'
+} as const;
+
+export type BotResponse =
+    | UnpinResponse
+    | Reaction
+    | TextMessage
+    | VideoMessage
+    | ImageMessage;
+
+export interface IChatResponse {
+    kind: keyof typeof BotResponseTypes;
+    chatId: number;
+    traceId: number | string;
+    sourceActionKey: string;
+}
+
+export interface IReplyMessage<TType> extends IChatResponse {
+    content: TType;
+    replyId: number | undefined;
+    disableWebPreview: boolean;
+    shouldPin: boolean;
+}

package/types/storage.ts

@@ -1,9 +1,13 @@
-import ActionStateBase from '../entities/states/actionStateBase';
-import TransactionResult from '../entities/transactionResult';
-import IActionState from './actionState';
-import IActionWithState from './actionWithState';
+import { ActionExecutionResult } from '../entities/actionExecutionResult';
+import { IActionState } from './actionState';
+import { IActionWithState } from './actionWithState';
 
 export interface IStorageClient {
+    updateStateFor<TActionState extends IActionState>(
+        sourceActionKey: string,
+        chatId: number,
+        update: (state: TActionState) => Promise<void>
+    ): Promise<void>;
     close(): Promise<void>;
     load<TActionState extends IActionState>(
         key: string
@@ -16,6 +20,6 @@ export interface IStorageClient {
     saveActionExecutionResult(
         action: IActionWithState,
         chatId: number,
-        transactionResult: TransactionResult
+        transactionResult: ActionExecutionResult
     ): Promise<void>;
 }

package/dist/entities/bot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../../entities/bot.ts"],"names":[],"mappings":"AAKA,OAAO,aAAa,MAAM,yBAAyB,CAAC;AACpD,OAAO,eAAe,MAAM,2BAA2B,CAAC;AACxD,OAAO,YAAY,MAAM,sBAAsB,CAAC;AAOhD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,CAAC,OAAO,OAAO,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,GAAG,CAAqB;IAChC,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,YAAY,CAAyB;IAC7C,OAAO,EAAE,cAAc,CAAC;gBAEZ,OAAO,EAAE;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,EAAE,CAAC;QACxC,SAAS,EAAE,eAAe,EAAE,CAAC;QAC7B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC3B,aAAa,CAAC,EAAE,cAAc,CAAC;QAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;KACxB;IAuEK,IAAI,CAAC,IAAI,EAAE,MAAM;YAYT,YAAY;YAqBZ,eAAe;CAmBhC"}

package/dist/entities/transactionResult.d.ts

@@ -1,7 +0,0 @@
-import IActionState from '../types/actionState';
-export default class TransactionResult {
-    data: IActionState;
-    shouldUpdate: boolean;
-    constructor(data: IActionState, shouldUpdate: boolean);
-}
-//# sourceMappingURL=transactionResult.d.ts.map

package/dist/entities/transactionResult.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transactionResult.d.ts","sourceRoot":"","sources":["../../entities/transactionResult.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,sBAAsB,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,iBAAiB;IAClC,IAAI,EAAE,YAAY,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;gBAEV,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO;CAIxD"}

package/types/replyMessage.ts

@@ -1,7 +0,0 @@
-export default interface IReplyMessage<TType> {
-    content: TType;
-    chatId: number;
-    replyId: number | undefined;
-    traceId: number | string;
-    disableWebPreview: boolean;
-}