chz-telegram-bot 0.5.5 → 0.6.9

package/entities/botInstance.ts

@@ -4,21 +4,19 @@ import { JsonFileStorage } from '../services/jsonFileStorage';
 import { IActionState } from '../types/actionState';
 import { CommandAction } from './actions/commandAction';
 import { ScheduledAction } from './actions/scheduledAction';
-import { JsonLogger } from '../services/jsonLogger';
-import { ILogger } from '../types/logger';
 import { IScheduler } from '../types/scheduler';
 import { NodeTimeoutScheduler } from '../services/nodeTimeoutScheduler';
-import { createTrace } from '../helpers/traceFactory';
 import { InlineQueryAction } from './actions/inlineQueryAction';
 import { ActionProcessingService } from '../services/actionProcessingService';
+import { BotEventType, TypedEventEmitter } from '../types/events';
 
 export class BotInstance {
     private readonly storage: IStorageClient;
     private readonly scheduler: IScheduler;
-    private readonly logger: ILogger;
     private readonly actionProcessingService: ActionProcessingService;
 
     readonly name: string;
+    readonly eventEmitter = new TypedEventEmitter();
 
     constructor(options: {
         name: string;
@@ -31,7 +29,6 @@ export class BotInstance {
         storagePath?: string;
         services?: {
             storageClient?: IStorageClient;
-            logger?: ILogger;
             scheduler?: IScheduler;
         };
     }) {
@@ -42,19 +39,23 @@ export class BotInstance {
 
         this.name = options.name;
 
-        this.logger = options.services?.logger ?? new JsonLogger();
         this.scheduler =
             options.services?.scheduler ??
-            new NodeTimeoutScheduler(this.logger);
+            new NodeTimeoutScheduler(this.eventEmitter);
         this.storage =
             options.services?.storageClient ??
-            new JsonFileStorage(options.name, actions, options.storagePath);
+            new JsonFileStorage(
+                options.name,
+                actions,
+                this.eventEmitter,
+                options.storagePath
+            );
         this.actionProcessingService = new ActionProcessingService(
             this.name,
             options.chats,
             this.storage,
             this.scheduler,
-            this.logger
+            this.eventEmitter
         );
     }
 
@@ -65,31 +66,23 @@ export class BotInstance {
             scheduled: ScheduledAction<IActionState>[];
             inlineQueries: InlineQueryAction[];
         },
-        scheduledPeriod?: Seconds,
-        verboseLoggingForIncomingMessage?: boolean
+        scheduledPeriod?: Seconds
     ) {
-        this.logger.logWithTraceId(
-            this.name,
-            createTrace(this, this.name, 'Start'),
-            'System',
-            'Starting bot...'
-        );
+        this.eventEmitter.emit(BotEventType.botStarting, {
+            botName: this.name
+        });
 
         await this.actionProcessingService.initialize(
             token,
             actions,
-            scheduledPeriod,
-            verboseLoggingForIncomingMessage
+            scheduledPeriod
         );
     }
 
     async stop() {
-        this.logger.logWithTraceId(
-            this.name,
-            createTrace(this, this.name, 'Stop'),
-            'System',
-            'Stopping bot...'
-        );
+        this.eventEmitter.emit(BotEventType.botStopping, {
+            botName: this.name
+        });
 
         this.scheduler.stopAll();
         await this.storage.close();

package/entities/context/baseContext.ts

@@ -3,7 +3,7 @@ import { IAction, IActionWithState } from '../../types/action';
 import { IActionState } from '../../types/actionState';
 import { ICaptureController } from '../../types/capture';
 import { CommandTrigger } from '../../types/commandTrigger';
-import { IScopedLogger } from '../../types/logger';
+import { TypedEventEmitter } from '../../types/events';
 import { BotResponse, IReplyResponse } from '../../types/response';
 import { IScheduler } from '../../types/scheduler';
 import { IStorageClient } from '../../types/storage';
@@ -15,7 +15,7 @@ export type BaseContextPropertiesToOmit =
     | 'isInitialized'
     | 'storage'
     | 'scheduler'
-    | 'logger'
+    | 'eventEmitter'
     | 'responses'
     | 'traceId';
 
@@ -29,7 +29,7 @@ export abstract class BaseContextInternal<TAction extends IAction> {
     readonly storage: IStorageClient;
     /** Scheduler instance for the bot executing this action */
     readonly scheduler: IScheduler;
-    logger!: IScopedLogger;
+    readonly eventEmitter: TypedEventEmitter;
     /** Trace id of a action execution. */
     traceId!: TraceId;
     /** Name of a bot that executes this action. */
@@ -48,9 +48,14 @@ export abstract class BaseContextInternal<TAction extends IAction> {
         this._responses = value;
     }
 
-    constructor(storage: IStorageClient, scheduler: IScheduler) {
+    constructor(
+        storage: IStorageClient,
+        scheduler: IScheduler,
+        eventEmitter: TypedEventEmitter
+    ) {
         this.storage = storage;
         this.scheduler = scheduler;
+        this.eventEmitter = eventEmitter;
     }
 
     protected createCaptureController(

package/index.ts

@@ -9,7 +9,6 @@ export * from './helpers/timeConvertions';
 export * from './types/action';
 export * from './types/externalAliases';
 export * from './types/storage';
-export * from './types/logger';
 export * from './types/scheduler';
 export { CommandAction } from './entities/actions/commandAction';
 export { InlineQueryAction } from './entities/actions/inlineQueryAction';
@@ -24,3 +23,4 @@ export { ICaptureController } from './types/capture';
 export { ChatInfo } from './dtos/chatInfo';
 export { MessageInfo } from './dtos/messageInfo';
 export { UserInfo } from './dtos/userInfo';
+export { BotEventType } from './types/events';

package/main.ts

@@ -5,7 +5,6 @@ import { ScheduledAction } from './entities/actions/scheduledAction';
 import { BotInstance } from './entities/botInstance';
 import { Seconds } from './types/timeValues';
 import { IScheduler } from './types/scheduler';
-import { ILogger } from './types/logger';
 import { InlineQueryAction } from './entities/actions/inlineQueryAction';
 import { IActionState } from './types/actionState';
 
@@ -39,8 +38,6 @@ class BotOrchestrator {
         services?: {
             /** Storage client for bot state storage. If not provided, default `JsonFileStorage` will be used. */
             storageClient?: IStorageClient;
-            /** Logger client for bot logging. If not provided, default `JsonFileStorage` will be used. */
-            logger?: ILogger;
             /** Scheduler client for bot scheduling. If not provided, default `NodeTimeoutScheduler` will be used. */
             scheduler?: IScheduler;
         };
@@ -53,18 +50,12 @@ class BotOrchestrator {
             chats: options.chats,
             services: {
                 storageClient: options.services?.storageClient,
-                logger: options.services?.logger,
                 scheduler: options.services?.scheduler
             },
             storagePath: options.storagePath
         });
 
-        await bot.start(
-            token,
-            options.actions,
-            options.scheduledPeriod,
-            options.verboseLoggingForIncomingMessage
-        );
+        await bot.start(token, options.actions, options.scheduledPeriod);
         this.bots.push(bot);
 
         return bot;

package/package.json

@@ -14,7 +14,7 @@
         "type": "git",
         "url": "https://github.com/AlexSolari/botFramework.git"
     },
-    "version": "0.5.5",
+    "version": "0.6.9",
     "type": "module",
     "dependencies": {
         "async-sema": "^3.1.1",

package/services/actionProcessingService.ts

@@ -1,6 +1,5 @@
 import { hoursToSeconds } from '../helpers/timeConvertions';
 import { Seconds, Milliseconds, Hours } from '../types/timeValues';
-import { ILogger } from '../types/logger';
 import { IScheduler } from '../types/scheduler';
 import { IStorageClient } from '../types/storage';
 import { TelegramApiService } from './telegramApi';
@@ -14,11 +13,11 @@ import { InlineQueryActionProcessor } from './actionProcessors/inlineQueryAction
 import { ScheduledActionProcessor } from './actionProcessors/scheduledActionProcessor';
 import { TelegramBot } from '../types/externalAliases';
 import { Telegraf } from 'telegraf';
+import { TypedEventEmitter } from '../types/events';
 
 export class ActionProcessingService {
+    private readonly eventEmitter: TypedEventEmitter;
     private readonly storage: IStorageClient;
-    private readonly logger: ILogger;
-
     private readonly commandProcessor: CommandActionProcessor;
     private readonly scheduledProcessor: ScheduledActionProcessor;
     private readonly inlineQueryProcessor: InlineQueryActionProcessor;
@@ -32,29 +31,29 @@ export class ActionProcessingService {
         chats: Record<string, number>,
         storage: IStorageClient,
         scheduler: IScheduler,
-        logger: ILogger
+        eventEmitter: TypedEventEmitter
     ) {
         this.storage = storage;
-        this.logger = logger;
+        this.eventEmitter = eventEmitter;
 
         this.commandProcessor = new CommandActionProcessor(
             botName,
             storage,
             scheduler,
-            logger
+            this.eventEmitter
         );
         this.scheduledProcessor = new ScheduledActionProcessor(
             botName,
             chats,
             storage,
             scheduler,
-            logger
+            this.eventEmitter
         );
         this.inlineQueryProcessor = new InlineQueryActionProcessor(
             botName,
             storage,
             scheduler,
-            logger
+            this.eventEmitter
         );
 
         this.botName = botName;
@@ -67,21 +66,19 @@ export class ActionProcessingService {
             scheduled: ScheduledAction<IActionState>[];
             inlineQueries: InlineQueryAction[];
         },
-        scheduledPeriod?: Seconds,
-        verboseLoggingForIncomingMessage?: boolean
+        scheduledPeriod?: Seconds
     ) {
         this.telegramBot = new Telegraf(token);
         const api = new TelegramApiService(
             this.botName,
             this.telegramBot.telegram,
             this.storage,
-            this.logger,
-            (capture, id, chatInfo, traceId) => {
+            this.eventEmitter,
+            (capture, id, chatInfo) => {
                 this.commandProcessor.captureRegistrationCallback(
                     capture,
                     id,
-                    chatInfo,
-                    traceId
+                    chatInfo
                 );
             }
         );
@@ -104,7 +101,6 @@ export class ActionProcessingService {
             api,
             this.telegramBot,
             commandActions,
-            verboseLoggingForIncomingMessage ?? false,
             botInfo
         );
         this.inlineQueryProcessor.initialize(

package/services/actionProcessors/baseProcessor.ts

@@ -1,14 +1,14 @@
-import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';
 import { IStorageClient } from '../../types/storage';
 import { TelegramApiService } from '../telegramApi';
 import { IAction } from '../../types/action';
 import { BaseContextInternal } from '../../entities/context/baseContext';
+import { BotEventType, TypedEventEmitter } from '../../types/events';
 
 export abstract class BaseActionProcessor {
     protected readonly storage: IStorageClient;
     protected readonly scheduler: IScheduler;
-    protected readonly logger: ILogger;
+    protected readonly eventEmitter: TypedEventEmitter;
 
     protected readonly botName: string;
 
@@ -18,20 +18,17 @@ export abstract class BaseActionProcessor {
         botName: string,
         storage: IStorageClient,
         scheduler: IScheduler,
-        logger: ILogger
+        eventEmitter: TypedEventEmitter
     ) {
         this.storage = storage;
         this.scheduler = scheduler;
-        this.logger = logger;
+        this.eventEmitter = eventEmitter;
 
         this.botName = botName;
     }
 
-    private defaultErrorHandler<TAction extends IAction>(
-        error: Error,
-        ctx: BaseContextInternal<TAction>
-    ) {
-        ctx.logger.errorWithTraceId(error, ctx);
+    private defaultErrorHandler(error: Error) {
+        this.eventEmitter.emit(BotEventType.error, { error });
     }
 
     initializeDependencies(api: TelegramApiService) {
@@ -52,6 +49,9 @@ export abstract class BaseActionProcessor {
             ctx.isInitialized = false;
         } catch (error) {
             (errorHandler ?? this.defaultErrorHandler)(error as Error, ctx);
+            this.eventEmitter.emit(BotEventType.error, {
+                error: error as Error
+            });
         }
     }
 }

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;
     }
 
@@ -77,13 +77,16 @@ export class ScheduledActionProcessor extends BaseActionProcessor {
                 delay as Milliseconds,
                 this.botName
             );
+
+            void this.runScheduled();
         }
     }
 
     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 +121,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
-        );
     }
 }