chz-telegram-bot 0.5.4 → 0.6.8

package/entities/actions/replyCaptureAction.ts

@@ -4,6 +4,7 @@ import { IActionState } from '../../types/actionState';
 import { CommandTrigger } from '../../types/commandTrigger';
 import { ActionKey, IAction } from '../../types/action';
 import { ReplyContextInternal } from '../context/replyContext';
+import { BotEventType } from '../../types/events';
 
 export class ReplyCaptureAction<TParentActionState extends IActionState>
     implements IAction
@@ -50,13 +51,18 @@ export class ReplyCaptureAction<TParentActionState extends IActionState>
 
         if (!shouldExecute) return Noop.NoResponse;
 
-        ctx.logger.logWithTraceId(
-            ` - Executing [${this.key}] in ${ctx.chatInfo.id}`
-        );
+        ctx.eventEmitter.emit(BotEventType.replyActionExecuting, {
+            action: this,
+            ctx
+        });
         ctx.matchResults = matchResults;
 
         await this.handler(ctx);
 
+        ctx.eventEmitter.emit(BotEventType.replyActionExecuted, {
+            action: this,
+            ctx
+        });
         return ctx.responses;
     }
 

package/entities/actions/scheduledAction.ts

@@ -8,10 +8,10 @@ import { IActionWithState, ActionKey } from '../../types/action';
 import { CachedStateFactory } from '../cachedStateFactory';
 import { ChatContextInternal } from '../context/chatContext';
 import { Noop } from '../../helpers/noop';
-import { IScheduler } from '../../types/scheduler';
 import { getOrSetIfNotExists, getOrThrow } from '../../helpers/mapUtils';
 import { ScheduledActionPropertyProvider } from '../../types/propertyProvider';
 import { ScheduledActionProviders } from '../../dtos/propertyProviderSets';
+import { BotEventType } from '../../types/events';
 
 export class ScheduledAction<TActionState extends IActionState>
     implements IActionWithState<TActionState>
@@ -71,14 +71,15 @@ export class ScheduledAction<TActionState extends IActionState>
         const isAllowedToTrigger = this.checkIfShouldBeExecuted(state, ctx);
         if (!isAllowedToTrigger) return Noop.NoResponse;
 
-        ctx.logger.logWithTraceId(
-            ` - Executing [${this.name}] in ${ctx.chatInfo.id}`
-        );
+        ctx.eventEmitter.emit(BotEventType.scheduledActionExecuting, {
+            action: this,
+            ctx,
+            state
+        });
 
         await this.handler(
             ctx,
-            <TResult>(key: string) =>
-                this.getCachedValue<TResult>(key, ctx.botName, ctx.scheduler),
+            <TResult>(key: string) => this.getCachedValue<TResult>(key, ctx),
             state
         );
 
@@ -90,13 +91,17 @@ export class ScheduledAction<TActionState extends IActionState>
             state
         );
 
+        ctx.eventEmitter.emit(BotEventType.scheduledActionExecuted, {
+            action: this,
+            ctx,
+            state
+        });
         return ctx.responses;
     }
 
     private async getCachedValue<TResult>(
         key: string,
-        botName: string,
-        scheduler: IScheduler
+        ctx: ChatContextInternal<TActionState>
     ): Promise<TResult> {
         const cachedItemFactory = getOrThrow(
             this.cachedStateFactories,
@@ -118,21 +123,37 @@ export class ScheduledAction<TActionState extends IActionState>
                 return this.cachedState.get(key) as TResult;
             }
 
+            ctx.eventEmitter.emit(
+                BotEventType.scheduledActionCacheValueCreating,
+                {
+                    action: this,
+                    ctx,
+                    key
+                }
+            );
             const value = await cachedItemFactory.getValue();
 
             this.cachedState.set(key, value);
 
-            scheduler.createOnetimeTask(
+            ctx.scheduler.createOnetimeTask(
                 `Drop cached value [${this.name} : ${key}]`,
                 () => this.cachedState.delete(key),
                 hoursToMilliseconds(
                     cachedItemFactory.invalidationTimeoutInHours
                 ),
-                botName
+                ctx.botName
             );
 
             return value as TResult;
         } finally {
+            ctx.eventEmitter.emit(
+                BotEventType.scheduledActionCacheValueReturned,
+                {
+                    action: this,
+                    ctx,
+                    key
+                }
+            );
             semaphore.release();
         }
     }

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

@@ -1,38 +1,38 @@
-{
-    "name": "chz-telegram-bot",
-    "description": "Opinionated TypeScript framework that provides a structured approach to building Telegram bots.",
-    "author": {
-        "name": "Alex Halanin",
-        "url": "https://github.com/AlexSolari"
-    },
-    "license": "MIT",
-    "keywords": [
-        "telegram",
-        "telegram bot"
-    ],
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/AlexSolari/botFramework.git"
-    },
-    "version": "0.5.4",
-    "type": "module",
-    "dependencies": {
-        "async-sema": "^3.1.1",
-        "moment": "^2.29.4",
-        "telegraf": "^4.16.3"
-    },
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "devDependencies": {
-        "@eslint/js": "^9.29.0",
-        "@types/node": "^22.5.5",
-        "eslint": "^9.29.0",
-        "jiti": "^2.6.1",
-        "typescript": "^5.9.0-beta",
-        "typescript-eslint": "^8.34.1"
-    },
-    "scripts": {
-        "build": "tsc",
-        "lint": "npx eslint && tsc --noEmit"
-    }
-}
+{
+    "name": "chz-telegram-bot",
+    "description": "Opinionated TypeScript framework that provides a structured approach to building Telegram bots.",
+    "author": {
+        "name": "Alex Halanin",
+        "url": "https://github.com/AlexSolari"
+    },
+    "license": "MIT",
+    "keywords": [
+        "telegram",
+        "telegram bot"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/AlexSolari/botFramework.git"
+    },
+    "version": "0.6.8",
+    "type": "module",
+    "dependencies": {
+        "async-sema": "^3.1.1",
+        "moment": "^2.29.4",
+        "telegraf": "^4.16.3"
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "devDependencies": {
+        "@eslint/js": "^9.29.0",
+        "@types/node": "^22.5.5",
+        "eslint": "^9.29.0",
+        "jiti": "^2.6.1",
+        "typescript": "^5.9.0-beta",
+        "typescript-eslint": "^8.34.1"
+    },
+    "scripts": {
+        "build": "tsc",
+        "lint": "npx eslint && tsc --noEmit"
+    }
+}

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
+            });
         }
     }
 }