chz-telegram-bot 0.2.1 → 0.3.0

package/services/actionProcessors/commandActionProcessor.ts

@@ -0,0 +1,242 @@
+import { Telegraf } from 'telegraf';
+import { IncomingMessage } from '../../dtos/incomingMessage';
+import { CommandAction } from '../../entities/actions/commandAction';
+import { ReplyCaptureAction } from '../../entities/actions/replyCaptureAction';
+import { MessageContext } from '../../entities/context/messageContext';
+import { ReplyContext } from '../../entities/context/replyContext';
+import { IActionWithState } from '../../types/action';
+import { IActionState } from '../../types/actionState';
+import { ILogger } from '../../types/logger';
+import {
+    INTERNAL_MESSAGE_TYPE_PREFIX,
+    MessageType
+} from '../../types/messageTypes';
+import { IScheduler } from '../../types/scheduler';
+import { IStorageClient } from '../../types/storage';
+import { TelegramApiService } from '../telegramApi';
+import { IReplyCapture } from '../../types/capture';
+import { TraceId } from '../../types/trace';
+import { ChatInfo } from '../../dtos/chatInfo';
+
+export class CommandActionProcessor {
+    private readonly storage: IStorageClient;
+    private readonly scheduler: IScheduler;
+    private readonly logger: ILogger;
+
+    private readonly botName: string;
+    private readonly replyCaptures: ReplyCaptureAction<IActionState>[];
+
+    private api!: TelegramApiService;
+    private telegraf!: Telegraf;
+    private commands!: CommandAction<IActionState>[];
+
+    private permanentTriggersToBeProcessed!: Set<string>;
+
+    constructor(
+        botName: string,
+        storage: IStorageClient,
+        scheduler: IScheduler,
+        logger: ILogger
+    ) {
+        this.storage = storage;
+        this.scheduler = scheduler;
+        this.logger = logger;
+
+        this.botName = botName;
+        this.replyCaptures = [];
+    }
+
+    initialize(
+        api: TelegramApiService,
+        telegraf: Telegraf,
+        commands: CommandAction<IActionState>[],
+        verboseLoggingForIncomingMessage: boolean
+    ) {
+        this.api = api;
+        this.telegraf = telegraf;
+        this.commands = commands;
+
+        if (this.commands.length > 0) {
+            this.permanentTriggersToBeProcessed = new Set(
+                this.commands
+                    .flatMap((x) => x.triggers)
+                    .map((x) =>
+                        typeof x == 'string'
+                            ? x.startsWith(INTERNAL_MESSAGE_TYPE_PREFIX)
+                                ? x
+                                : MessageType.Text
+                            : MessageType.Text
+                    )
+            );
+
+            this.telegraf.on('message', async (ctx) => {
+                const msg = new IncomingMessage(
+                    ctx.update.message,
+                    this.botName
+                );
+
+                if (verboseLoggingForIncomingMessage) {
+                    this.logger.logObjectWithTraceId(
+                        this.botName,
+                        msg.traceId,
+                        msg.chatInfo.name,
+                        ctx.update.message
+                    );
+                } else {
+                    this.logger.logWithTraceId(
+                        this.botName,
+                        msg.traceId,
+                        msg.chatInfo.name,
+                        `${msg.from?.first_name ?? 'Unknown'} (${
+                            msg.from?.id ?? 'Unknown'
+                        }): ${msg.text || `<non-text message: ${msg.type}>`}`
+                    );
+                }
+
+                if (
+                    this.permanentTriggersToBeProcessed.has(msg.type) ||
+                    this.replyCaptures.find(
+                        (x) => x.parentMessageId == msg.replyToMessageId
+                    )
+                )
+                    await this.processMessage(msg);
+            });
+        }
+    }
+
+    captureRegistrationCallback(
+        capture: IReplyCapture,
+        parentMessageId: number,
+        chatInfo: ChatInfo,
+        traceId: TraceId
+    ) {
+        const replyAction = new ReplyCaptureAction(
+            parentMessageId,
+            capture.action,
+            capture.handler,
+            capture.trigger,
+            capture.abortController
+        );
+
+        this.logger.logWithTraceId(
+            this.botName,
+            traceId,
+            chatInfo.name,
+            `Starting capturing replies to message ${parentMessageId} with action ${replyAction.key}`
+        );
+
+        this.replyCaptures.push(replyAction);
+
+        capture.abortController.signal.addEventListener('abort', () => {
+            const index = this.replyCaptures.indexOf(replyAction);
+            this.replyCaptures.splice(index, 1);
+
+            this.logger.logWithTraceId(
+                this.botName,
+                traceId,
+                chatInfo.name,
+                `Stopping capturing replies to message ${parentMessageId} with action ${replyAction.key}`
+            );
+        });
+    }
+
+    private async processMessage(msg: IncomingMessage) {
+        const ctx = new MessageContext<IActionState>(
+            this.storage,
+            this.logger,
+            this.scheduler
+        );
+
+        for (const commandAction of this.commands) {
+            this.initializeMessageContext(ctx, commandAction, msg);
+
+            try {
+                const responses = await commandAction.exec(ctx);
+                this.api.enqueueBatchedResponses(responses);
+                ctx.isInitialized = false;
+            } catch (error) {
+                this.logger.errorWithTraceId(
+                    ctx.botName,
+                    ctx.traceId,
+                    ctx.chatInfo.name,
+                    error,
+                    ctx
+                );
+            }
+        }
+
+        const replyCtx = new ReplyContext<IActionState>(
+            this.storage,
+            this.logger,
+            this.scheduler
+        );
+
+        for (const replyAction of this.replyCaptures) {
+            this.initializeReplyCaptureContext(replyCtx, replyAction, msg);
+
+            try {
+                const responses = await replyAction.exec(replyCtx);
+                this.api.enqueueBatchedResponses(responses);
+                replyCtx.isInitialized = false;
+            } catch (error) {
+                this.logger.errorWithTraceId(
+                    replyCtx.botName,
+                    replyCtx.traceId,
+                    replyCtx.chatInfo.name,
+                    error,
+                    replyCtx
+                );
+            }
+        }
+
+        this.api.flushResponses();
+    }
+
+    private initializeReplyCaptureContext(
+        ctx: ReplyContext<IActionState>,
+        action: ReplyCaptureAction<IActionState>,
+        message: IncomingMessage
+    ) {
+        ctx.replyMessageId = message.replyToMessageId;
+        ctx.messageId = message.messageId;
+        ctx.messageText = message.text ?? '';
+        ctx.messageType = message.type;
+        ctx.fromUserId = message.from?.id;
+        ctx.fromUserName =
+            (message.from?.first_name ?? 'Unknown user') +
+            (message.from?.last_name ? ` ${message.from.last_name}` : '');
+        ctx.messageUpdateObject = message.updateObject;
+        ctx.botName = this.botName;
+        ctx.action = action;
+        ctx.chatInfo = message.chatInfo;
+        ctx.traceId = message.traceId;
+
+        ctx.isInitialized = true;
+        ctx.matchResults = [];
+    }
+
+    private initializeMessageContext<TActionState extends IActionState>(
+        ctx: MessageContext<IActionState>,
+        action: IActionWithState<TActionState>,
+        message: IncomingMessage
+    ) {
+        ctx.messageId = message.messageId;
+        ctx.messageText = message.text ?? '';
+        ctx.messageType = message.type;
+        ctx.fromUserId = message.from?.id;
+        ctx.fromUserName =
+            (message.from?.first_name ?? 'Unknown user') +
+            (message.from?.last_name ? ` ${message.from.last_name}` : '');
+        ctx.messageUpdateObject = message.updateObject;
+
+        ctx.matchResults = [];
+        ctx.startCooldown = true;
+
+        ctx.responses = [];
+        ctx.isInitialized = true;
+        ctx.botName = this.botName;
+        ctx.action = action;
+        ctx.chatInfo = message.chatInfo;
+        ctx.traceId = message.traceId;
+    }
+}

package/services/actionProcessors/inlineQueryActionProcessor.ts

@@ -0,0 +1,176 @@
+import { Telegraf } from 'telegraf';
+import { IncomingInlineQuery } from '../../dtos/incomingQuery';
+import { InlineQueryAction } from '../../entities/actions/inlineQueryAction';
+import { InlineQueryContext } from '../../entities/context/inlineQueryContext';
+import { createTrace } from '../../helpers/traceFactory';
+import { ILogger } from '../../types/logger';
+import { IScheduler } from '../../types/scheduler';
+import { IStorageClient } from '../../types/storage';
+import { Milliseconds } from '../../types/timeValues';
+import { TraceId } from '../../types/trace';
+import { TelegramApiService } from '../telegramApi';
+
+export class InlineQueryActionProcessor {
+    private readonly storage: IStorageClient;
+    private readonly scheduler: IScheduler;
+    private readonly logger: ILogger;
+
+    private readonly botName: string;
+
+    private api!: TelegramApiService;
+    private telegraf!: Telegraf;
+    private inlineQueries!: InlineQueryAction[];
+
+    constructor(
+        botName: string,
+        storage: IStorageClient,
+        scheduler: IScheduler,
+        logger: ILogger
+    ) {
+        this.storage = storage;
+        this.scheduler = scheduler;
+        this.logger = logger;
+
+        this.botName = botName;
+    }
+
+    initialize(
+        api: TelegramApiService,
+        telegraf: Telegraf,
+        inlineQueries: InlineQueryAction[],
+        period: Milliseconds
+    ) {
+        this.api = api;
+        this.telegraf = telegraf;
+        this.inlineQueries = inlineQueries;
+
+        let pendingInlineQueries: IncomingInlineQuery[] = [];
+
+        const queriesInProcessing = new Map<number, IncomingInlineQuery>();
+
+        if (this.inlineQueries.length > 0) {
+            this.telegraf.on('inline_query', async (ctx) => {
+                const query = new IncomingInlineQuery(
+                    ctx.inlineQuery.id,
+                    ctx.inlineQuery.query,
+                    ctx.inlineQuery.from.id,
+                    createTrace('InlineQuery', this.botName, ctx.inlineQuery.id)
+                );
+
+                this.logger.logWithTraceId(
+                    this.botName,
+                    query.traceId,
+                    'Query',
+                    `${ctx.inlineQuery.from.username} (${ctx.inlineQuery.from.id}): Query for ${ctx.inlineQuery.query}`
+                );
+
+                const queryBeingProcessed = queriesInProcessing.get(
+                    query.userId
+                );
+                if (queryBeingProcessed) {
+                    this.logger.logWithTraceId(
+                        this.botName,
+                        query.traceId,
+                        'Query',
+                        `Aborting query ${queryBeingProcessed.queryId} (${queryBeingProcessed.query}): new query recieved from ${query.userId}`
+                    );
+
+                    queryBeingProcessed.abortController.abort();
+                    queriesInProcessing.delete(query.userId);
+                }
+
+                pendingInlineQueries = pendingInlineQueries.filter(
+                    (q) => q.userId != query.userId
+                );
+
+                pendingInlineQueries.push(query);
+            });
+
+            this.scheduler.createTask(
+                'InlineQueryProcessing',
+                async () => {
+                    const ctx = new InlineQueryContext(
+                        this.storage,
+                        this.logger,
+                        this.scheduler
+                    );
+
+                    const queriesToProcess = [...pendingInlineQueries];
+                    pendingInlineQueries = [];
+
+                    for (const inlineQuery of queriesToProcess) {
+                        queriesInProcessing.set(
+                            inlineQuery.userId,
+                            inlineQuery
+                        );
+
+                        for (const inlineQueryAction of this.inlineQueries) {
+                            this.initializeInlineQueryContext(
+                                ctx,
+                                inlineQuery.query,
+                                inlineQuery.queryId,
+                                inlineQueryAction,
+                                inlineQuery.abortController.signal,
+                                inlineQuery.traceId
+                            );
+
+                            try {
+                                const responses = await inlineQueryAction.exec(
+                                    ctx
+                                );
+                                this.api.enqueueBatchedResponses(responses);
+                                ctx.isInitialized = false;
+                            } catch (err) {
+                                const error = err as Error;
+
+                                if (error.name == 'AbortError') {
+                                    this.logger.logWithTraceId(
+                                        this.botName,
+                                        inlineQuery.traceId,
+                                        'Query',
+                                        `Aborting query ${inlineQuery.queryId} (${inlineQuery.query}) successful.`
+                                    );
+                                } else {
+                                    this.logger.errorWithTraceId(
+                                        ctx.botName,
+                                        ctx.traceId,
+                                        'Unknown',
+                                        error,
+                                        ctx
+                                    );
+                                }
+                            }
+                        }
+
+                        queriesInProcessing.delete(inlineQuery.userId);
+                    }
+
+                    this.api.flushResponses();
+                },
+                period,
+                false,
+                this.botName
+            );
+        }
+    }
+
+    private initializeInlineQueryContext(
+        ctx: InlineQueryContext,
+        queryText: string,
+        queryId: string,
+        action: InlineQueryAction,
+        abortSignal: AbortSignal,
+        traceId: TraceId
+    ) {
+        ctx.queryText = queryText;
+        ctx.queryId = queryId;
+        ctx.botName = this.botName;
+        ctx.action = action;
+        ctx.traceId = traceId;
+        ctx.abortSignal = abortSignal;
+
+        ctx.isInitialized = true;
+        ctx.queryResults = [];
+        ctx.matchResults = [];
+    }
+}

package/services/actionProcessors/scheduledActionProcessor.ts

@@ -0,0 +1,145 @@
+import moment from 'moment';
+import { ChatInfo } from '../../dtos/chatInfo';
+import { ScheduledAction } from '../../entities/actions/scheduledAction';
+import { ChatContext } from '../../entities/context/chatContext';
+import { secondsToMilliseconds } from '../../helpers/timeConvertions';
+import { createTrace } from '../../helpers/traceFactory';
+import { IActionWithState } from '../../types/action';
+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';
+
+export class ScheduledActionProcessor {
+    private readonly storage: IStorageClient;
+    private readonly scheduler: IScheduler;
+    private readonly logger: ILogger;
+
+    private readonly botName: string;
+    private readonly chats: Record<string, number>;
+
+    private api!: TelegramApiService;
+    private scheduled!: ScheduledAction<IActionState>[];
+
+    constructor(
+        botName: string,
+        chats: Record<string, number>,
+        storage: IStorageClient,
+        scheduler: IScheduler,
+        logger: ILogger
+    ) {
+        this.storage = storage;
+        this.scheduler = scheduler;
+        this.logger = logger;
+
+        this.botName = botName;
+        this.chats = chats;
+    }
+
+    initialize(
+        api: TelegramApiService,
+        scheduled: ScheduledAction<IActionState>[],
+        period: Seconds
+    ) {
+        this.api = api;
+        this.scheduled = scheduled;
+
+        if (this.scheduled.length > 0) {
+            const now = moment();
+
+            if (now.minute() == 0 && now.second() == 0) {
+                this.scheduler.createTask(
+                    'ScheduledProcessing',
+                    async () => {
+                        await this.runScheduled();
+                    },
+                    secondsToMilliseconds(period),
+                    true,
+                    this.botName
+                );
+
+                return;
+            }
+
+            let nextExecutionTime = now.clone().startOf('hour');
+            if (now.minute() > 0 || now.second() > 0) {
+                nextExecutionTime = nextExecutionTime.add(1, 'hour');
+            }
+
+            const delay = nextExecutionTime.diff(now);
+
+            this.scheduler.createOnetimeTask(
+                'ScheduledProcessing_OneTime',
+                async () => {
+                    this.scheduler.createTask(
+                        'ScheduledProcessing',
+                        async () => {
+                            await this.runScheduled();
+                        },
+                        secondsToMilliseconds(period),
+                        true,
+                        this.botName
+                    );
+                },
+                delay as Milliseconds,
+                this.botName
+            );
+        }
+    }
+
+    private async runScheduled() {
+        const ctx = new ChatContext<IActionState>(
+            this.storage,
+            this.logger,
+            this.scheduler
+        );
+
+        for (const [chatName, chatId] of Object.entries(this.chats)) {
+            for (const scheduledAction of this.scheduled) {
+                this.initializeChatContext(
+                    ctx,
+                    scheduledAction,
+                    new ChatInfo(chatId, chatName),
+                    createTrace(
+                        scheduledAction,
+                        this.botName,
+                        `${scheduledAction.key}-${chatId}`
+                    )
+                );
+
+                try {
+                    const responses = await scheduledAction.exec(ctx);
+                    this.api.enqueueBatchedResponses(responses);
+                    ctx.isInitialized = false;
+                } catch (error) {
+                    this.logger.errorWithTraceId(
+                        ctx.botName,
+                        ctx.traceId,
+                        chatName,
+                        error,
+                        ctx
+                    );
+                }
+            }
+        }
+
+        this.api.flushResponses();
+    }
+
+    private initializeChatContext<TActionState extends IActionState>(
+        ctx: ChatContext<IActionState>,
+        action: IActionWithState<TActionState>,
+        chatInfo: ChatInfo,
+        traceId: TraceId
+    ) {
+        ctx.responses = [];
+        ctx.isInitialized = true;
+        ctx.botName = this.botName;
+        ctx.action = action;
+        ctx.chatInfo = chatInfo;
+        ctx.traceId = traceId;
+    }
+}

package/services/jsonFileStorage.ts

@@ -3,7 +3,7 @@ import { readFile, writeFile } from 'fs/promises';
 import { Sema as Semaphore } from 'async-sema';
 import { IStorageClient } from '../types/storage';
 import { IActionState } from '../types/actionState';
-import { IActionWithState, ActionKey } from '../types/statefulAction';
+import { IActionWithState, ActionKey } from '../types/action';
 
 export class JsonFileStorage implements IStorageClient {
     private readonly locks = new Map<ActionKey, Semaphore>();