chz-telegram-bot 0.5.5 → 0.6.8

package/dist/services/telegramApi.js

@@ -1,17 +1,28 @@
 import { ResponseProcessingQueue } from './responseProcessingQueue';
+import { BotEventType } from '../types/events';
 export const TELEGRAM_ERROR_QUOTE_INVALID = 'QUOTE_TEXT_INVALID';
 export class TelegramApiService {
     queue = new ResponseProcessingQueue();
     telegram;
     storage;
-    logger;
+    eventEmitter;
     captureRegistrationCallback;
     botName;
-    constructor(botName, telegram, storage, logger, captureRegistrationCallback) {
+    methodMap = {
+        inlineQuery: 'answerInlineQuery',
+        text: 'sendMessage',
+        react: 'setMessageReaction',
+        unpin: 'unpinChatMessage',
+        pin: 'pinChatMessage',
+        image: 'sendPhoto',
+        video: 'sendVideo',
+        delay: null
+    };
+    constructor(botName, telegram, storage, eventEmitter, captureRegistrationCallback) {
         this.telegram = telegram;
         this.botName = botName;
         this.storage = storage;
-        this.logger = logger;
+        this.eventEmitter = eventEmitter;
         this.captureRegistrationCallback = captureRegistrationCallback;
     }
     enqueueBatchedResponses(responses) {
@@ -23,9 +34,6 @@ export class TelegramApiService {
             }
             const queueItem = {
                 callback: async () => {
-                    const scopedLogger = this.logger.createScope(this.botName, response.traceId, 'chatInfo' in response
-                        ? response.chatInfo.name
-                        : 'Unknown');
                     try {
                         await this.processResponse(response);
                     }
@@ -33,17 +41,23 @@ export class TelegramApiService {
                         if ('message' in error) {
                             const telegramResponse = error;
                             if (telegramResponse.message.includes(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
+                                    });
                                 }
                                 return;
                             }
                         }
-                        scopedLogger.errorWithTraceId(error, response);
+                        this.eventEmitter.emit(BotEventType.error, {
+                            error: error
+                        });
                     }
                 },
                 priority: response.createdAt + offset
@@ -56,7 +70,15 @@ export class TelegramApiService {
     }
     async pinIfShould(response, message) {
         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, response.chatInfo.id, (state) => {
                 state.pinnedMessages.push(message.message_id);
             });
@@ -64,6 +86,10 @@ export class TelegramApiService {
     }
     async processResponse(response, 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);
             for (const capture of response.captures) {
@@ -72,6 +98,10 @@ export class TelegramApiService {
         }
     }
     async sendApiRequest(response, ignoreQuote) {
+        this.eventEmitter.emit(BotEventType.apiRequestSending, {
+            response,
+            telegramMethod: this.methodMap[response.kind]
+        });
         switch (response.kind) {
             case 'text':
                 return await this.telegram.sendMessage(response.chatInfo.id, response.content, {

package/dist/types/events.d.ts

@@ -0,0 +1,193 @@
+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 declare const BotEventType: {
+    readonly error: "error.generic";
+    readonly messageRecieved: "message.recieved";
+    readonly messageProcessingStarted: "message.processingStarted";
+    readonly messageProcessingFinished: "message.processingFinished";
+    readonly beforeActionsExecuting: "message.beforeActionsExecuting";
+    readonly commandActionExecuting: "command.actionExecuting";
+    readonly commandActionExecuted: "command.actionExecuted";
+    readonly commandActionCaptureStarted: "command.captionStarted";
+    readonly commandActionCaptureAborted: "command.captionAborted";
+    readonly replyActionExecuting: "reply.actionExecuting";
+    readonly replyActionExecuted: "reply.actionExecuted";
+    readonly inlineActionExecuting: "inline.actionExecuting";
+    readonly inlineActionExecuted: "inline.actionExecuted";
+    readonly inlineProcessingStarted: "inline.processingStarted";
+    readonly inlineProcessingAborting: "inline.processingAborting";
+    readonly inlineProcessingAborted: "inline.processingAborted";
+    readonly scheduledActionExecuting: "scheduled.actionExecuting";
+    readonly scheduledActionExecuted: "scheduled.actionExecuted";
+    readonly scheduledActionCacheValueReturned: "scheduled.cachedValueReturned";
+    readonly scheduledActionCacheValueCreating: "scheduled.cachedValueCreating";
+    readonly apiRequestSending: "api.requestSending";
+    readonly apiRequestSent: "api.requestSent";
+    readonly storageLockAcquiring: "storage.lockAcquiring";
+    readonly storageLockAcquired: "storage.lockAcquired";
+    readonly storageLockReleased: "storage.lockReleased";
+    readonly storageStateSaving: "storage.stateSaving";
+    readonly storageStateSaved: "storage.stateSaved";
+    readonly storageStateLoading: "storage.stateLoading";
+    readonly storageStateLoaded: "storage.stateLoaded";
+    readonly taskCreated: "task.created";
+    readonly taskRun: "task.run";
+    readonly botStarting: "bot.starting";
+    readonly botStopping: "bot.stopping";
+};
+type BotEventTypeKeys = (typeof BotEventType)[keyof typeof BotEventType];
+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 declare class TypedEventEmitter {
+    private readonly listeners;
+    on<K extends keyof BotEventMap>(event: K, fn: Listener<K>): void;
+    onEach(fn: EachListener): void;
+    emit<K extends keyof BotEventMap>(event: K, ...args: ListenerArgs<K>): void;
+    events(): (keyof BotEventMap | '*')[];
+}
+export {};
+//# sourceMappingURL=events.d.ts.map

package/dist/types/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../types/events.ts"],"names":[],"mappings":"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"}

package/dist/types/events.js

@@ -0,0 +1,69 @@
+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'
+};
+// Exhaustiveness validation
+const _checkBotEventMapExhaustive = null;
+export class TypedEventEmitter {
+    listeners = new Map();
+    on(event, fn) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(fn);
+        this.listeners.set(event, set);
+    }
+    onEach(fn) {
+        const event = '*';
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(fn);
+        this.listeners.set(event, set);
+    }
+    emit(event, ...args) {
+        const timestamp = Date.now();
+        const specific = this.listeners.get(event);
+        if (specific) {
+            for (const fn of specific) {
+                fn(timestamp, ...args);
+            }
+        }
+        const anySet = this.listeners.get('*');
+        if (anySet) {
+            for (const fn of anySet) {
+                fn(event, timestamp, ...args);
+            }
+        }
+    }
+    events() {
+        return [...this.listeners.keys()];
+    }
+}

package/dist/types/logger.d.ts

@@ -1,13 +1 @@
-import { TraceId } from './trace';
-export interface IScopedLogger {
-    logObjectWithTraceId(data: unknown): void;
-    logWithTraceId(text: string): void;
-    errorWithTraceId(errorObj: unknown, extraData?: unknown): void;
-}
-export interface ILogger {
-    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=logger.d.ts.map

package/dist/types/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../types/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC,MAAM,WAAW,aAAa;IAC1B,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAE1C,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEnC,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAClE;AAED,MAAM,WAAW,OAAO;IACpB,WAAW,CACP,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,GACjB,aAAa,CAAC;IAEjB,oBAAoB,CAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,GACd,IAAI,CAAC;IAER,cAAc,CACV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACb,IAAI,CAAC;IAER,gBAAgB,CACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,EACjB,SAAS,CAAC,EAAE,OAAO,GACpB,IAAI,CAAC;CACX"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../types/logger.ts"],"names":[],"mappings":""}

package/dist/types/logger.js

@@ -1 +1 @@
-export {};
+"use strict";

package/entities/actions/commandAction.ts

@@ -19,6 +19,7 @@ import { Seconds } from '../../types/timeValues';
 import { CommandActionPropertyProvider } from '../../types/propertyProvider';
 import { CommandActionProviders } from '../../dtos/propertyProviderSets';
 import { BotResponse } from '../../types/response';
+import { BotEventType } from '../../types/events';
 
 export class CommandAction<TActionState extends IActionState>
     implements IActionWithState<TActionState>
@@ -133,9 +134,11 @@ export class CommandAction<TActionState extends IActionState>
                 return Noop.NoResponse;
             }
 
-            ctx.logger.logWithTraceId(
-                ` - Executing [${this.name}] in ${ctx.chatInfo.id}`
-            );
+            ctx.eventEmitter.emit(BotEventType.commandActionExecuting, {
+                action: this,
+                ctx,
+                state
+            });
             ctx.matchResults = matchResults;
 
             await this.handler(ctx, state);
@@ -156,6 +159,11 @@ export class CommandAction<TActionState extends IActionState>
                 state
             );
 
+            ctx.eventEmitter.emit(BotEventType.commandActionExecuted, {
+                action: this,
+                ctx,
+                state
+            });
             return ctx.responses;
         } finally {
             lock?.release();

package/entities/actions/inlineQueryAction.ts

@@ -3,6 +3,7 @@ import { ActionKey, IAction } from '../../types/action';
 import { InlineQueryContextInternal } from '../context/inlineQueryContext';
 import { InlineQueryHandler } from '../../types/handlers';
 import { InlineActionPropertyProvider } from '../../types/propertyProvider';
+import { BotEventType } from '../../types/events';
 
 export class InlineQueryAction implements IAction {
     readonly key: ActionKey;
@@ -58,10 +59,17 @@ export class InlineQueryAction implements IAction {
 
         ctx.matchResults = matchResults;
 
-        ctx.logger.logWithTraceId(` - Executing [${this.name}]`);
+        ctx.eventEmitter.emit(BotEventType.inlineActionExecuting, {
+            action: this,
+            ctx
+        });
 
         await this.handler(ctx);
 
+        ctx.eventEmitter.emit(BotEventType.inlineActionExecuted, {
+            action: this,
+            ctx
+        });
         return ctx.responses;
     }
 }

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