chz-telegram-bot 0.5.5 → 0.6.8

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(

package/types/events.ts

@@ -0,0 +1,285 @@
+import { ChatInfo } from '../dtos/chatInfo';
+import { IncomingMessage } from '../dtos/incomingMessage';
+import { IncomingInlineQuery } from '../dtos/incomingQuery';
+import { CommandAction } from '../entities/actions/commandAction';
+import { ChatContext } from '../entities/context/chatContext';
+import { InlineQueryContext } from '../entities/context/inlineQueryContext';
+import { MessageContext } from '../entities/context/messageContext';
+import { ReplyContext } from '../entities/context/replyContext';
+import { ActionKey, IAction, IActionWithState } from './action';
+import { IActionState } from './actionState';
+import { BotInfo } from './externalAliases';
+import { BotResponse } from './response';
+import { Milliseconds } from './timeValues';
+
+export const BotEventType = {
+    error: 'error.generic',
+
+    messageRecieved: 'message.recieved',
+    messageProcessingStarted: 'message.processingStarted',
+    messageProcessingFinished: 'message.processingFinished',
+    beforeActionsExecuting: 'message.beforeActionsExecuting',
+
+    commandActionExecuting: 'command.actionExecuting',
+    commandActionExecuted: 'command.actionExecuted',
+    commandActionCaptureStarted: 'command.captionStarted',
+    commandActionCaptureAborted: 'command.captionAborted',
+
+    replyActionExecuting: 'reply.actionExecuting',
+    replyActionExecuted: 'reply.actionExecuted',
+
+    inlineActionExecuting: 'inline.actionExecuting',
+    inlineActionExecuted: 'inline.actionExecuted',
+    inlineProcessingStarted: 'inline.processingStarted',
+    inlineProcessingAborting: 'inline.processingAborting',
+    inlineProcessingAborted: 'inline.processingAborted',
+
+    scheduledActionExecuting: 'scheduled.actionExecuting',
+    scheduledActionExecuted: 'scheduled.actionExecuted',
+    scheduledActionCacheValueReturned: 'scheduled.cachedValueReturned',
+    scheduledActionCacheValueCreating: 'scheduled.cachedValueCreating',
+
+    apiRequestSending: 'api.requestSending',
+    apiRequestSent: 'api.requestSent',
+
+    storageLockAcquiring: 'storage.lockAcquiring',
+    storageLockAcquired: 'storage.lockAcquired',
+    storageLockReleased: 'storage.lockReleased',
+    storageStateSaving: 'storage.stateSaving',
+    storageStateSaved: 'storage.stateSaved',
+    storageStateLoading: 'storage.stateLoading',
+    storageStateLoaded: 'storage.stateLoaded',
+
+    taskCreated: 'task.created',
+    taskRun: 'task.run',
+
+    botStarting: 'bot.starting',
+    botStopping: 'bot.stopping'
+} as const;
+
+type BotEventTypeKeys = (typeof BotEventType)[keyof typeof BotEventType];
+// Exhaustiveness validation
+const _checkBotEventMapExhaustive: Record<BotEventTypeKeys, unknown> =
+    null as unknown as BotEventMap;
+
+export type BotEventMap = {
+    [BotEventType.error]: {
+        error: Error;
+    };
+
+    [BotEventType.messageRecieved]: {
+        botInfo: BotInfo;
+        message: IncomingMessage;
+    };
+
+    [BotEventType.messageProcessingStarted]: {
+        botInfo: BotInfo;
+        message: IncomingMessage;
+    };
+
+    [BotEventType.messageProcessingFinished]: {
+        botInfo: BotInfo;
+        message: IncomingMessage;
+    };
+
+    [BotEventType.beforeActionsExecuting]: {
+        botInfo: BotInfo;
+        message: IncomingMessage;
+        commands: Set<CommandAction<IActionState>>;
+    };
+
+    [BotEventType.commandActionExecuting]: {
+        action: IActionWithState<IActionState>;
+        ctx: MessageContext<IActionState>;
+        state: IActionState;
+    };
+
+    [BotEventType.commandActionExecuted]: {
+        action: IActionWithState<IActionState>;
+        ctx: MessageContext<IActionState>;
+        state: IActionState;
+    };
+
+    [BotEventType.commandActionCaptureStarted]: {
+        parentMessageId: number;
+        chatInfo: ChatInfo;
+    };
+
+    [BotEventType.commandActionCaptureAborted]: {
+        parentMessageId: number;
+        chatInfo: ChatInfo;
+    };
+
+    [BotEventType.replyActionExecuting]: {
+        action: IAction;
+        ctx: ReplyContext<IActionState>;
+    };
+
+    [BotEventType.replyActionExecuted]: {
+        action: IAction;
+        ctx: ReplyContext<IActionState>;
+    };
+
+    [BotEventType.inlineActionExecuting]: {
+        action: IAction;
+        ctx: InlineQueryContext;
+    };
+
+    [BotEventType.inlineActionExecuted]: {
+        action: IAction;
+        ctx: InlineQueryContext;
+    };
+
+    [BotEventType.inlineProcessingStarted]: {
+        query: IncomingInlineQuery;
+    };
+
+    [BotEventType.inlineProcessingAborting]: {
+        abortedQuery: IncomingInlineQuery;
+        newQuery: IncomingInlineQuery;
+    };
+
+    [BotEventType.inlineProcessingAborted]: {
+        abortedQuery: IncomingInlineQuery;
+    };
+
+    [BotEventType.scheduledActionExecuting]: {
+        action: IAction;
+        ctx: ChatContext<IActionState>;
+        state: IActionState;
+    };
+
+    [BotEventType.scheduledActionExecuted]: {
+        action: IAction;
+        ctx: ChatContext<IActionState>;
+        state: IActionState;
+    };
+
+    [BotEventType.scheduledActionCacheValueCreating]: {
+        action: IAction;
+        ctx: ChatContext<IActionState>;
+        key: string;
+    };
+
+    [BotEventType.scheduledActionCacheValueReturned]: {
+        action: IAction;
+        ctx: ChatContext<IActionState>;
+        key: string;
+    };
+
+    [BotEventType.apiRequestSending]: {
+        response: BotResponse | null;
+        telegramMethod: string | null;
+    };
+
+    [BotEventType.apiRequestSent]: {
+        response: BotResponse | null;
+        telegramMethod: string | null;
+    };
+
+    [BotEventType.storageLockAcquiring]: ActionKey;
+    [BotEventType.storageLockAcquired]: ActionKey;
+    [BotEventType.storageLockReleased]: ActionKey;
+    [BotEventType.storageStateSaved]: {
+        key: ActionKey;
+        data: Record<number, unknown>;
+    };
+    [BotEventType.storageStateSaving]: {
+        key: ActionKey;
+        data: Record<number, unknown>;
+    };
+    [BotEventType.storageStateLoading]: {
+        action: IActionWithState<IActionState>;
+        chatId: number;
+    };
+    [BotEventType.storageStateLoaded]: {
+        action: IActionWithState<IActionState>;
+        chatId: number;
+        state: IActionState;
+    };
+
+    [BotEventType.taskCreated]: {
+        name: string;
+        ownerName: string;
+        delay?: Milliseconds;
+        interval?: Milliseconds;
+    };
+    [BotEventType.taskRun]: {
+        name: string;
+        ownerName: string;
+        delay?: Milliseconds;
+        interval?: Milliseconds;
+    };
+
+    [BotEventType.botStarting]: {
+        botName: string;
+    };
+
+    [BotEventType.botStopping]: {
+        botName: string;
+    };
+};
+
+type ListenerArgs<K extends keyof BotEventMap> =
+    BotEventMap[K] extends undefined ? [] : [BotEventMap[K]];
+
+export type Listener<K extends keyof BotEventMap> = (
+    timestamp: number,
+    ...args: ListenerArgs<K>
+) => void;
+
+export type EachListener = (
+    event: BotEventTypeKeys,
+    timestamp: number,
+    data: unknown
+) => void;
+
+export class TypedEventEmitter {
+    private readonly listeners = new Map<
+        keyof BotEventMap | '*',
+        Set<Listener<keyof BotEventMap> | EachListener>
+    >();
+
+    on<K extends keyof BotEventMap>(event: K, fn: Listener<K>) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(fn as Listener<keyof BotEventMap>);
+        this.listeners.set(event, set);
+    }
+
+    onEach(fn: EachListener) {
+        const event = '*';
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(fn);
+        this.listeners.set(event, set);
+    }
+
+    emit<K extends keyof BotEventMap>(
+        event: K,
+        ...args: ListenerArgs<K>
+    ): void {
+        const timestamp = Date.now();
+        const specific = this.listeners.get(event);
+        if (specific) {
+            for (const fn of specific) {
+                (fn as Listener<K>)(timestamp, ...args);
+            }
+        }
+
+        const anySet = this.listeners.get('*');
+        if (anySet) {
+            for (const fn of anySet) {
+                (
+                    fn as unknown as (
+                        e: K,
+                        t: number,
+                        ...a: ListenerArgs<K>
+                    ) => void
+                )(event, timestamp, ...args);
+            }
+        }
+    }
+
+    events(): (keyof BotEventMap | '*')[] {
+        return [...this.listeners.keys()];
+    }
+}

package/dist/services/jsonLogger.d.ts

@@ -1,11 +0,0 @@
-import { ILogger, IScopedLogger } from '../types/logger';
-import { TraceId } from '../types/trace';
-export declare class JsonLogger implements ILogger {
-    private serializeError;
-    private getCircularReplacer;
-    createScope(botName: string, traceId: TraceId, chatName: string): IScopedLogger;
-    logObjectWithTraceId(botName: string, traceId: TraceId, chatName: string, data: unknown): void;
-    logWithTraceId(botName: string, traceId: TraceId, chatName: string, text: string): void;
-    errorWithTraceId(botName: string, traceId: TraceId, chatName: string, errorObj: unknown, extraData?: unknown): void;
-}
-//# sourceMappingURL=jsonLogger.d.ts.map

package/dist/services/jsonLogger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonLogger.d.ts","sourceRoot":"","sources":["../../services/jsonLogger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzC,qBAAa,UAAW,YAAW,OAAO;IACtC,OAAO,CAAC,cAAc;IAkBtB,OAAO,CAAC,mBAAmB;IAc3B,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAiBtD,aAAa;IAGtB,oBAAoB,CAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO;IAoBjB,cAAc,CACV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM;IAOhB,gBAAgB,CACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,EACjB,SAAS,CAAC,EAAE,OAAO;CAe1B"}

package/dist/services/jsonLogger.js

@@ -1,66 +0,0 @@
-export class JsonLogger {
-    serializeError(error) {
-        if (error instanceof Error) {
-            const plainObject = {
-                name: error.name,
-                message: error.message,
-                stack: error.stack
-            };
-            for (const [key, value] of Object.entries(error)) {
-                plainObject[key] = value;
-            }
-            return JSON.stringify(plainObject);
-        }
-        return JSON.stringify({ error });
-    }
-    getCircularReplacer() {
-        const cache = new Set();
-        return (_, value) => {
-            if (typeof value === 'object' && value !== null) {
-                if (cache.has(value)) {
-                    return;
-                }
-                cache.add(value);
-            }
-            return value;
-        };
-    }
-    createScope(botName, traceId, chatName) {
-        return {
-            logObjectWithTraceId: (data) => {
-                this.logObjectWithTraceId(botName, traceId, chatName, data);
-            },
-            logWithTraceId: (text) => {
-                this.logWithTraceId(botName, traceId, chatName, text);
-            },
-            errorWithTraceId: (errorObj, extraData) => {
-                this.errorWithTraceId(botName, traceId, chatName, errorObj, extraData);
-            }
-        };
-    }
-    logObjectWithTraceId(botName, traceId, chatName, data) {
-        const enrichedData = typeof data == 'object'
-            ? {
-                ...data,
-                botName,
-                traceId,
-                chatName
-            }
-            : {
-                botName,
-                traceId,
-                chatName,
-                data
-            };
-        console.log(enrichedData);
-    }
-    logWithTraceId(botName, traceId, chatName, text) {
-        console.log(`{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","text":"${text}"}`);
-    }
-    errorWithTraceId(botName, traceId, chatName, errorObj, extraData) {
-        const dataString = extraData
-            ? `,"extraData":${JSON.stringify(extraData, this.getCircularReplacer())}`
-            : '';
-        console.error(`{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","error":${this.serializeError(errorObj)}${dataString}}`);
-    }
-}