chz-telegram-bot 0.5.4 → 0.6.8

package/services/actionProcessors/commandActionProcessor.ts

@@ -6,7 +6,6 @@ import { ReplyContextInternal } from '../../entities/context/replyContext';
 import { IActionState } from '../../types/actionState';
 import { TelegramApiService } from '../telegramApi';
 import { IReplyCapture } from '../../types/capture';
-import { TraceId } from '../../types/trace';
 import { ChatInfo } from '../../dtos/chatInfo';
 import {
     INTERNAL_MESSAGE_TYPE_PREFIX,
@@ -19,6 +18,7 @@ import { MessageInfo } from '../../dtos/messageInfo';
 import { UserInfo } from '../../dtos/userInfo';
 import { ChatHistoryMessage } from '../../dtos/chatHistoryMessage';
 import { BotInfo, TelegramBot } from '../../types/externalAliases';
+import { BotEventType } from '../../types/events';
 
 const MESSAGE_HISTORY_LENGTH_LIMIT = 100;
 
@@ -38,7 +38,6 @@ export class CommandActionProcessor extends BaseActionProcessor {
         api: TelegramApiService,
         telegram: TelegramBot,
         commands: CommandAction<IActionState>[],
-        verboseLoggingForIncomingMessage: boolean,
         botInfo: BotInfo
     ) {
         this.botInfo = botInfo;
@@ -69,30 +68,24 @@ export class CommandActionProcessor extends BaseActionProcessor {
         }
 
         if (commands.length > 0) {
-            telegram.on('message', ({ message }) => {
+            telegram.on('message', async ({ message }) => {
                 const internalMessage = new IncomingMessage(
                     message,
                     this.botName,
                     getOrSetIfNotExists(this.chatHistory, message.chat.id, [])
                 );
 
-                const logger = this.logger.createScope(
-                    this.botName,
-                    internalMessage.traceId,
-                    internalMessage.chatInfo.name
-                );
+                this.eventEmitter.emit(BotEventType.messageRecieved, {
+                    botInfo: this.botInfo,
+                    message: internalMessage
+                });
 
-                if (verboseLoggingForIncomingMessage) {
-                    logger.logObjectWithTraceId(message);
-                } else {
-                    logger.logWithTraceId(
-                        `${internalMessage.from?.first_name ?? 'Unknown'} (${
-                            internalMessage.from?.id ?? 'Unknown'
-                        }): ${internalMessage.text || internalMessage.type}`
-                    );
-                }
+                await this.processMessage(internalMessage);
 
-                void this.processMessage(internalMessage);
+                this.eventEmitter.emit(BotEventType.messageProcessingFinished, {
+                    botInfo: this.botInfo,
+                    message: internalMessage
+                });
             });
         }
     }
@@ -100,8 +93,7 @@ export class CommandActionProcessor extends BaseActionProcessor {
     captureRegistrationCallback(
         capture: IReplyCapture,
         parentMessageId: number,
-        chatInfo: ChatInfo,
-        traceId: TraceId
+        chatInfo: ChatInfo
     ) {
         const replyAction = new ReplyCaptureAction(
             parentMessageId,
@@ -111,15 +103,10 @@ export class CommandActionProcessor extends BaseActionProcessor {
             capture.abortController
         );
 
-        const logger = this.logger.createScope(
-            this.botName,
-            traceId,
-            chatInfo.name
-        );
-
-        logger.logWithTraceId(
-            `Starting capturing replies to message ${parentMessageId} with action ${replyAction.key}`
-        );
+        this.eventEmitter.emit(BotEventType.commandActionCaptureStarted, {
+            parentMessageId,
+            chatInfo
+        });
 
         this.replyCaptures.push(replyAction);
 
@@ -127,13 +114,19 @@ export class CommandActionProcessor extends BaseActionProcessor {
             const index = this.replyCaptures.indexOf(replyAction);
             this.replyCaptures.splice(index, 1);
 
-            logger.logWithTraceId(
-                `Stopping capturing replies to message ${parentMessageId} with action ${replyAction.key}`
-            );
+            this.eventEmitter.emit(BotEventType.commandActionCaptureAborted, {
+                parentMessageId,
+                chatInfo
+            });
         });
     }
 
     private async processMessage(msg: IncomingMessage) {
+        this.eventEmitter.emit(BotEventType.messageProcessingStarted, {
+            botInfo: this.botInfo,
+            message: msg
+        });
+
         const chatHistoryArray = getOrSetIfNotExists(
             this.chatHistory,
             msg.chatInfo.id,
@@ -142,6 +135,7 @@ export class CommandActionProcessor extends BaseActionProcessor {
 
         while (chatHistoryArray.length > MESSAGE_HISTORY_LENGTH_LIMIT)
             chatHistoryArray.shift();
+
         chatHistoryArray.push(
             new ChatHistoryMessage(
                 msg.messageId,
@@ -156,7 +150,8 @@ export class CommandActionProcessor extends BaseActionProcessor {
 
         const ctx = new MessageContextInternal<IActionState>(
             this.storage,
-            this.scheduler
+            this.scheduler,
+            this.eventEmitter
         );
 
         const commandsToCheck = new Set(this.commands[msg.type]);
@@ -166,6 +161,11 @@ export class CommandActionProcessor extends BaseActionProcessor {
             }
         }
 
+        this.eventEmitter.emit(BotEventType.beforeActionsExecuting, {
+            botInfo: this.botInfo,
+            message: msg,
+            commands: commandsToCheck
+        });
         for (const commandAction of commandsToCheck) {
             this.initializeMessageContext(ctx, commandAction, msg);
             await this.executeAction(commandAction, ctx);
@@ -174,7 +174,8 @@ export class CommandActionProcessor extends BaseActionProcessor {
         if (this.replyCaptures.length != 0) {
             const replyCtx = new ReplyContextInternal<IActionState>(
                 this.storage,
-                this.scheduler
+                this.scheduler,
+                this.eventEmitter
             );
 
             for (const replyAction of this.replyCaptures) {
@@ -211,12 +212,6 @@ export class CommandActionProcessor extends BaseActionProcessor {
 
         ctx.isInitialized = true;
         ctx.matchResults = [];
-
-        ctx.logger = this.logger.createScope(
-            this.botName,
-            message.traceId,
-            message.chatInfo.name
-        );
     }
 
     private initializeMessageContext(
@@ -247,11 +242,5 @@ export class CommandActionProcessor extends BaseActionProcessor {
         ctx.traceId = message.traceId;
         ctx.botInfo = this.botInfo;
         ctx.customCooldown = undefined;
-
-        ctx.logger = this.logger.createScope(
-            this.botName,
-            message.traceId,
-            message.chatInfo.name
-        );
     }
 }

package/services/actionProcessors/inlineQueryActionProcessor.ts

@@ -2,6 +2,7 @@ import { IncomingInlineQuery } from '../../dtos/incomingQuery';
 import { InlineQueryAction } from '../../entities/actions/inlineQueryAction';
 import { InlineQueryContextInternal } from '../../entities/context/inlineQueryContext';
 import { createTrace } from '../../helpers/traceFactory';
+import { BotEventType } from '../../types/events';
 import { TelegramBot } from '../../types/externalAliases';
 import { Milliseconds } from '../../types/timeValues';
 import { TraceId } from '../../types/trace';
@@ -33,24 +34,20 @@ export class InlineQueryActionProcessor extends BaseActionProcessor {
                     createTrace('InlineQuery', this.botName, inlineQuery.id)
                 );
 
-                const logger = this.logger.createScope(
-                    this.botName,
-                    query.traceId,
-                    'Query'
-                );
-
-                logger.logWithTraceId(
-                    `${inlineQuery.from.username ?? 'Unknown'} (${
-                        inlineQuery.from.id
-                    }): Query for ${inlineQuery.query}`
-                );
+                this.eventEmitter.emit(BotEventType.inlineProcessingStarted, {
+                    query
+                });
 
                 const queryBeingProcessed = queriesInProcessing.get(
                     query.userId
                 );
                 if (queryBeingProcessed) {
-                    logger.logWithTraceId(
-                        `Aborting query ${queryBeingProcessed.queryId} (${queryBeingProcessed.query}): new query recieved from ${query.userId}`
+                    this.eventEmitter.emit(
+                        BotEventType.inlineProcessingAborting,
+                        {
+                            newQuery: query,
+                            abortedQuery: queryBeingProcessed
+                        }
                     );
 
                     queryBeingProcessed.abortController.abort();
@@ -69,7 +66,8 @@ export class InlineQueryActionProcessor extends BaseActionProcessor {
                 async () => {
                     const ctx = new InlineQueryContextInternal(
                         this.storage,
-                        this.scheduler
+                        this.scheduler,
+                        this.eventEmitter
                     );
 
                     const queriesToProcess = [...pendingInlineQueries];
@@ -94,13 +92,21 @@ export class InlineQueryActionProcessor extends BaseActionProcessor {
                             await this.executeAction(
                                 inlineQueryAction,
                                 ctx,
-                                (error, ctx) => {
+                                (error, _) => {
                                     if (error.name == 'AbortError') {
-                                        ctx.logger.logWithTraceId(
-                                            `Aborting query ${inlineQuery.queryId} (${inlineQuery.query}) successful.`
+                                        this.eventEmitter.emit(
+                                            BotEventType.inlineProcessingAborted,
+                                            {
+                                                abortedQuery: inlineQuery
+                                            }
                                         );
                                     } else {
-                                        ctx.logger.errorWithTraceId(error, ctx);
+                                        this.eventEmitter.emit(
+                                            BotEventType.error,
+                                            {
+                                                error
+                                            }
+                                        );
                                     }
                                 }
                             );
@@ -136,7 +142,5 @@ export class InlineQueryActionProcessor extends BaseActionProcessor {
         ctx.isInitialized = true;
         ctx.queryResults = [];
         ctx.matchResults = [];
-
-        ctx.logger = this.logger.createScope(this.botName, traceId, 'Unknown');
     }
 }

package/services/actionProcessors/scheduledActionProcessor.ts

@@ -5,13 +5,13 @@ import { ChatContextInternal } from '../../entities/context/chatContext';
 import { secondsToMilliseconds } from '../../helpers/timeConvertions';
 import { createTrace } from '../../helpers/traceFactory';
 import { IActionState } from '../../types/actionState';
-import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';
 import { IStorageClient } from '../../types/storage';
 import { Seconds, Milliseconds } from '../../types/timeValues';
 import { TraceId } from '../../types/trace';
 import { TelegramApiService } from '../telegramApi';
 import { BaseActionProcessor } from './baseProcessor';
+import { TypedEventEmitter } from '../../types/events';
 
 export class ScheduledActionProcessor extends BaseActionProcessor {
     private readonly chats: Record<string, number>;
@@ -23,9 +23,9 @@ export class ScheduledActionProcessor extends BaseActionProcessor {
         chats: Record<string, number>,
         storage: IStorageClient,
         scheduler: IScheduler,
-        logger: ILogger
+        eventEmitter: TypedEventEmitter
     ) {
-        super(botName, storage, scheduler, logger);
+        super(botName, storage, scheduler, eventEmitter);
         this.chats = chats;
     }
 
@@ -83,7 +83,8 @@ export class ScheduledActionProcessor extends BaseActionProcessor {
     private async runScheduled() {
         const ctx = new ChatContextInternal<IActionState>(
             this.storage,
-            this.scheduler
+            this.scheduler,
+            this.eventEmitter
         );
 
         for (const [chatName, chatId] of Object.entries(this.chats)) {
@@ -118,11 +119,5 @@ export class ScheduledActionProcessor extends BaseActionProcessor {
         ctx.action = action;
         ctx.chatInfo = chatInfo;
         ctx.traceId = traceId;
-
-        ctx.logger = this.logger.createScope(
-            this.botName,
-            traceId,
-            chatInfo.name
-        );
     }
 }

package/services/jsonFileStorage.ts

@@ -5,12 +5,14 @@ import { IStorageClient } from '../types/storage';
 import { IActionState } from '../types/actionState';
 import { IActionWithState, ActionKey } from '../types/action';
 import { getOrSetIfNotExists } from '../helpers/mapUtils';
+import { BotEventType, TypedEventEmitter } from '../types/events';
 
 function buildPath(storagePath: string, botName: string, actionKey: string) {
     return `${storagePath}/${botName}/${actionKey.replaceAll(':', '/')}.json`;
 }
 
 export class JsonFileStorage implements IStorageClient {
+    private readonly eventEmitter: TypedEventEmitter;
     private readonly filePaths = new Map<ActionKey, string>();
     private readonly locks = new Map<ActionKey, Semaphore>();
     private readonly cache: Map<string, Record<number, IActionState>>;
@@ -20,8 +22,10 @@ export class JsonFileStorage implements IStorageClient {
     constructor(
         botName: string,
         actions: IActionWithState<IActionState>[],
+        eventEmitter: TypedEventEmitter,
         path?: string
     ) {
+        this.eventEmitter = eventEmitter;
         this.cache = new Map<string, Record<number, IActionState>>();
         this.botName = botName;
         this.storagePath = path ?? 'storage';
@@ -57,12 +61,15 @@ export class JsonFileStorage implements IStorageClient {
     private async lock<TType>(key: ActionKey, action: () => Promise<TType>) {
         const lock = getOrSetIfNotExists(this.locks, key, new Semaphore(1));
 
+        this.eventEmitter.emit(BotEventType.storageLockAcquiring, key);
         await lock.acquire();
+        this.eventEmitter.emit(BotEventType.storageLockAcquired, key);
 
         try {
             return await action();
         } finally {
             lock.release();
+            this.eventEmitter.emit(BotEventType.storageLockReleased, key);
         }
     }
 
@@ -103,6 +110,10 @@ export class JsonFileStorage implements IStorageClient {
         data: Record<number, TActionState>,
         key: ActionKey
     ) {
+        this.eventEmitter.emit(BotEventType.storageStateSaving, {
+            data,
+            key
+        });
         this.cache.set(key, data);
 
         const targetPath = getOrSetIfNotExists(
@@ -112,6 +123,10 @@ export class JsonFileStorage implements IStorageClient {
         );
 
         await writeFile(targetPath, JSON.stringify(data), { flag: 'w+' });
+        this.eventEmitter.emit(BotEventType.storageStateSaved, {
+            data,
+            key
+        });
     }
 
     async load<TActionState extends IActionState>(key: ActionKey) {
@@ -135,13 +150,24 @@ export class JsonFileStorage implements IStorageClient {
         action: IActionWithState<TActionState>,
         chatId: number
     ) {
+        this.eventEmitter.emit(BotEventType.storageStateLoading, {
+            action,
+            chatId
+        });
         const value =
             this.tryGetFromCache<TActionState>(action.key) ??
             (await this.lock(action.key, async () => {
                 return await this.loadFromFile<TActionState>(action.key);
             }));
 
-        return Object.assign(action.stateConstructor(), value[chatId]);
+        const result = Object.assign(action.stateConstructor(), value[chatId]);
+
+        this.eventEmitter.emit(BotEventType.storageStateLoaded, {
+            action,
+            chatId,
+            state: result
+        });
+        return result;
     }
 
     async saveActionExecutionResult<TActionState extends IActionState>(

package/services/nodeTimeoutScheduler.ts

@@ -1,16 +1,12 @@
 import { TaskRecord } from '../entities/taskRecord';
-import { createTrace } from '../helpers/traceFactory';
-import { ILogger } from '../types/logger';
+import { BotEventType, TypedEventEmitter } from '../types/events';
 import { IScheduler } from '../types/scheduler';
 import { Milliseconds } from '../types/timeValues';
 
 export class NodeTimeoutScheduler implements IScheduler {
-    private readonly logger!: ILogger;
     readonly activeTasks: TaskRecord[] = [];
 
-    constructor(logger: ILogger) {
-        this.logger = logger;
-    }
+    constructor(readonly eventEmitter: TypedEventEmitter) {}
 
     stopAll() {
         for (const task of this.activeTasks) {
@@ -25,19 +21,25 @@ export class NodeTimeoutScheduler implements IScheduler {
         executeRightAway: boolean,
         ownerName: string
     ) {
-        const taskId = setInterval(action, interval);
+        const taskId = setInterval(() => {
+            action();
+            this.eventEmitter.emit(BotEventType.taskRun, {
+                name,
+                ownerName,
+                interval
+            });
+        }, interval);
         const task = new TaskRecord(name, taskId, interval);
 
         if (executeRightAway) {
             setImmediate(action);
         }
 
-        this.logger.logWithTraceId(
+        this.eventEmitter.emit(BotEventType.taskCreated, {
+            name,
             ownerName,
-            createTrace(this, ownerName, name),
-            'System',
-            `Created task ${name}, that will run every ${interval}ms.`
-        );
+            interval
+        });
 
         this.activeTasks.push(task);
     }
@@ -49,21 +51,19 @@ export class NodeTimeoutScheduler implements IScheduler {
         ownerName: string
     ) {
         const actionWrapper = () => {
-            this.logger.logWithTraceId(
+            this.eventEmitter.emit(BotEventType.taskRun, {
+                name,
                 ownerName,
-                createTrace(this, ownerName, name),
-                'System',
-                `Executing delayed oneshot ${name}`
-            );
+                delay
+            });
             action();
         };
         setTimeout(actionWrapper, delay);
 
-        this.logger.logWithTraceId(
+        this.eventEmitter.emit(BotEventType.taskCreated, {
+            name,
             ownerName,
-            createTrace(this, ownerName, name),
-            'System',
-            `Created oneshot task ${name}, that will run in ${delay}ms.`
-        );
+            delay
+        });
     }
 }

package/services/telegramApi.ts

@@ -1,6 +1,9 @@
 import { IStorageClient } from '../types/storage';
-import { BotResponse, IReplyResponse } from '../types/response';
-import { ILogger } from '../types/logger';
+import {
+    BotResponse,
+    BotResponseTypes,
+    IReplyResponse
+} from '../types/response';
 import { QueueItem, ResponseProcessingQueue } from './responseProcessingQueue';
 import { IReplyCapture } from '../types/capture';
 import { IActionWithState } from '../types/action';
@@ -8,6 +11,7 @@ import { IActionState } from '../types/actionState';
 import { TraceId } from '../types/trace';
 import { ChatInfo } from '../dtos/chatInfo';
 import { TelegramApiClient, TelegramMessage } from '../types/externalAliases';
+import { BotEventType, TypedEventEmitter } from '../types/events';
 
 export const TELEGRAM_ERROR_QUOTE_INVALID = 'QUOTE_TEXT_INVALID';
 
@@ -15,7 +19,7 @@ export class TelegramApiService {
     private readonly queue = new ResponseProcessingQueue();
     private readonly telegram: TelegramApiClient;
     private readonly storage: IStorageClient;
-    private readonly logger: ILogger;
+    private readonly eventEmitter: TypedEventEmitter;
     private readonly captureRegistrationCallback: (
         capture: IReplyCapture,
         parentMessageId: number,
@@ -25,22 +29,35 @@ export class TelegramApiService {
 
     private readonly botName: string;
 
+    private readonly methodMap: Record<
+        'pin' | keyof typeof BotResponseTypes,
+        string | null
+    > = {
+        inlineQuery: 'answerInlineQuery',
+        text: 'sendMessage',
+        react: 'setMessageReaction',
+        unpin: 'unpinChatMessage',
+        pin: 'pinChatMessage',
+        image: 'sendPhoto',
+        video: 'sendVideo',
+        delay: null
+    };
+
     constructor(
         botName: string,
         telegram: TelegramApiClient,
         storage: IStorageClient,
-        logger: ILogger,
+        eventEmitter: TypedEventEmitter,
         captureRegistrationCallback: (
             capture: IReplyCapture,
             parentMessageId: number,
-            chatInfo: ChatInfo,
-            traceId: TraceId
+            chatInfo: ChatInfo
         ) => void
     ) {
         this.telegram = telegram;
         this.botName = botName;
         this.storage = storage;
-        this.logger = logger;
+        this.eventEmitter = eventEmitter;
         this.captureRegistrationCallback = captureRegistrationCallback;
     }
 
@@ -54,14 +71,6 @@ export class TelegramApiService {
 
             const queueItem: QueueItem = {
                 callback: async () => {
-                    const scopedLogger = this.logger.createScope(
-                        this.botName,
-                        response.traceId,
-                        'chatInfo' in response
-                            ? response.chatInfo.name
-                            : 'Unknown'
-                    );
-
                     try {
                         await this.processResponse(response);
                     } catch (error) {
@@ -75,23 +84,27 @@ export class TelegramApiService {
                                     TELEGRAM_ERROR_QUOTE_INVALID
                                 )
                             ) {
-                                scopedLogger.logWithTraceId(
-                                    'Quote error recieved, retrying without quote'
-                                );
+                                this.eventEmitter.emit(BotEventType.error, {
+                                    error: new Error(
+                                        'Quote error recieved, retrying without quote'
+                                    )
+                                });
+
                                 try {
                                     await this.processResponse(response, true);
                                 } catch (error) {
-                                    scopedLogger.errorWithTraceId(
-                                        error,
-                                        response
-                                    );
+                                    this.eventEmitter.emit(BotEventType.error, {
+                                        error: error as Error
+                                    });
                                 }
 
                                 return;
                             }
                         }
 
-                        scopedLogger.errorWithTraceId(error, response);
+                        this.eventEmitter.emit(BotEventType.error, {
+                            error: error as Error
+                        });
                     }
                 },
                 priority: response.createdAt + offset
@@ -109,11 +122,19 @@ export class TelegramApiService {
         message: TelegramMessage
     ) {
         if (response.shouldPin) {
+            this.eventEmitter.emit(BotEventType.apiRequestSending, {
+                response: null,
+                telegramMethod: this.methodMap['pin']
+            });
             await this.telegram.pinChatMessage(
                 response.chatInfo.id,
                 message.message_id,
                 { disable_notification: true }
             );
+            this.eventEmitter.emit(BotEventType.apiRequestSent, {
+                response: null,
+                telegramMethod: this.methodMap['pin']
+            });
 
             await this.storage.updateStateFor(
                 response.action as IActionWithState<IActionState>,
@@ -127,6 +148,10 @@ export class TelegramApiService {
 
     private async processResponse(response: BotResponse, ignoreQuote = false) {
         const sentMessage = await this.sendApiRequest(response, ignoreQuote);
+        this.eventEmitter.emit(BotEventType.apiRequestSent, {
+            response,
+            telegramMethod: this.methodMap[response.kind]
+        });
 
         if (sentMessage && 'content' in response) {
             await this.pinIfShould(response, sentMessage);
@@ -146,6 +171,11 @@ export class TelegramApiService {
         response: BotResponse,
         ignoreQuote: boolean
     ): Promise<TelegramMessage | null> {
+        this.eventEmitter.emit(BotEventType.apiRequestSending, {
+            response,
+            telegramMethod: this.methodMap[response.kind]
+        });
+
         switch (response.kind) {
             case 'text':
                 return await this.telegram.sendMessage(