chz-telegram-bot 0.7.13 → 0.7.15

package/src/services/actionProcessors/commandActionProcessor.ts

@@ -1,231 +0,0 @@
-import { IncomingMessage } from '../../dtos/incomingMessage';
-import { CommandAction } from '../../entities/actions/commandAction';
-import { ReplyCaptureAction } from '../../entities/actions/replyCaptureAction';
-import { MessageContextInternal } from '../../entities/context/messageContext';
-import { ReplyContextInternal } from '../../entities/context/replyContext';
-import { IActionState } from '../../types/actionState';
-import { TelegramApiService } from '../telegramApi';
-import { IReplyCapture } from '../../types/capture';
-import { ChatInfo } from '../../dtos/chatInfo';
-import {
-    INTERNAL_MESSAGE_TYPE_PREFIX,
-    MessageType
-} from '../../types/messageTypes';
-import { typeSafeObjectFromEntries } from '../../helpers/objectFromEntries';
-import { BaseActionProcessor } from './baseProcessor';
-import { getOrSetIfNotExists } from '../../helpers/mapUtils';
-import { ChatHistoryMessage } from '../../dtos/chatHistoryMessage';
-import { BotInfo, TelegramBot } from '../../types/externalAliases';
-import { BotEventType } from '../../types/events';
-import { TraceId } from '../../types/trace';
-
-const MESSAGE_HISTORY_LENGTH_LIMIT = 100;
-
-export class CommandActionProcessor extends BaseActionProcessor {
-    private readonly replyCaptures: ReplyCaptureAction<IActionState>[] = [];
-    private readonly chatHistory = new Map<number, ChatHistoryMessage[]>();
-    private botInfo!: BotInfo;
-
-    private commands = typeSafeObjectFromEntries(
-        Object.values(MessageType).map((x) => [
-            x,
-            [] as CommandAction<IActionState>[]
-        ])
-    );
-
-    initialize(
-        api: TelegramApiService,
-        telegram: TelegramBot,
-        commands: CommandAction<IActionState>[],
-        botInfo: BotInfo
-    ) {
-        this.botInfo = botInfo;
-        this.initializeDependencies(api);
-
-        for (const msgType of Object.values(MessageType)) {
-            if (msgType == MessageType.Text) {
-                this.commands[msgType] = commands.filter(
-                    (cmd) =>
-                        cmd.triggers.some((x) => typeof x != 'string') ||
-                        cmd.triggers.some(
-                            (x) =>
-                                typeof x == 'string' &&
-                                !x.startsWith(INTERNAL_MESSAGE_TYPE_PREFIX)
-                        ) ||
-                        cmd.triggers.includes(MessageType.Text) ||
-                        cmd.triggers.includes(MessageType.Any)
-                );
-
-                continue;
-            }
-
-            this.commands[msgType] = commands.filter(
-                (cmd) =>
-                    cmd.triggers.includes(msgType) ||
-                    cmd.triggers.includes(MessageType.Any)
-            );
-        }
-
-        if (commands.length > 0) {
-            telegram.on('message', ({ message }) => {
-                const internalMessage = new IncomingMessage(
-                    message,
-                    this.botName,
-                    getOrSetIfNotExists(this.chatHistory, message.chat.id, [])
-                );
-
-                this.eventEmitter.emit(BotEventType.messageRecieved, {
-                    botInfo: this.botInfo,
-                    message: internalMessage,
-                    traceId: internalMessage.traceId
-                });
-
-                this.startMessageProcessing(internalMessage);
-            });
-        }
-    }
-
-    captureRegistrationCallback(
-        capture: IReplyCapture,
-        parentMessageId: number,
-        chatInfo: ChatInfo,
-        traceId: TraceId
-    ) {
-        const replyAction = new ReplyCaptureAction(
-            parentMessageId,
-            capture.action,
-            capture.handler,
-            capture.trigger,
-            capture.abortController
-        );
-
-        this.eventEmitter.emit(BotEventType.commandActionCaptureStarted, {
-            parentMessageId,
-            chatInfo,
-            traceId
-        });
-
-        this.replyCaptures.push(replyAction);
-
-        capture.abortController.signal.addEventListener(
-            'abort',
-            () => {
-                const capturesWithController = this.replyCaptures.filter(
-                    (x) => x.abortController == capture.abortController
-                );
-
-                for (const captureToCancel of capturesWithController) {
-                    const index = this.replyCaptures.indexOf(captureToCancel);
-                    this.replyCaptures.splice(index, 1);
-
-                    this.eventEmitter.emit(
-                        BotEventType.commandActionCaptureAborted,
-                        {
-                            parentMessageId,
-                            chatInfo,
-                            traceId
-                        }
-                    );
-                }
-            },
-            { once: true }
-        );
-    }
-
-    private startMessageProcessing(msg: IncomingMessage) {
-        this.eventEmitter.emit(BotEventType.messageProcessingStarted, {
-            botInfo: this.botInfo,
-            message: msg,
-            traceId: msg.traceId
-        });
-
-        const chatHistoryArray = getOrSetIfNotExists(
-            this.chatHistory,
-            msg.chatInfo.id,
-            []
-        );
-
-        while (chatHistoryArray.length > MESSAGE_HISTORY_LENGTH_LIMIT)
-            chatHistoryArray.shift();
-
-        chatHistoryArray.push(
-            new ChatHistoryMessage(
-                msg.messageId,
-                msg.from,
-                msg.text,
-                msg.type,
-                msg.traceId,
-                msg.replyToMessageId,
-                msg.updateObject.date
-            )
-        );
-
-        const commandsToCheck = new Set(this.commands[msg.type]);
-        if (msg.type != MessageType.Text && msg.text != '') {
-            for (const command of this.commands[MessageType.Text]) {
-                commandsToCheck.add(command);
-            }
-        }
-
-        this.eventEmitter.emit(BotEventType.beforeActionsExecuting, {
-            botInfo: this.botInfo,
-            message: msg,
-            commands: commandsToCheck,
-            traceId: msg.traceId
-        });
-
-        const promises = [...commandsToCheck].map((command) => {
-            const ctx = new MessageContextInternal<IActionState>(
-                this.storage,
-                this.scheduler,
-                this.eventEmitter,
-                command,
-                msg,
-                this.botName,
-                this.botInfo
-            );
-
-            const { proxy, revoke } = Proxy.revocable(ctx, {});
-
-            const executePromise = this.executeAction(command, proxy);
-
-            return executePromise.finally(() => {
-                revoke();
-                this.api.flushResponses();
-            });
-        });
-
-        if (this.replyCaptures.length != 0) {
-            const replyPromises = this.replyCaptures.map((capture) => {
-                const replyCtx = new ReplyContextInternal<IActionState>(
-                    this.storage,
-                    this.scheduler,
-                    this.eventEmitter,
-                    capture,
-                    msg,
-                    this.botName,
-                    this.botInfo
-                );
-
-                const { proxy, revoke } = Proxy.revocable(replyCtx, {});
-
-                const executePromise = this.executeAction(capture, proxy);
-
-                return executePromise.finally(() => {
-                    revoke();
-                    this.api.flushResponses();
-                });
-            });
-
-            promises.push(...replyPromises);
-        }
-
-        void Promise.allSettled(promises).then(() => {
-            this.eventEmitter.emit(BotEventType.messageProcessingFinished, {
-                botInfo: this.botInfo,
-                message: msg,
-                traceId: msg.traceId
-            });
-        });
-    }
-}

package/src/services/actionProcessors/inlineQueryActionProcessor.ts

@@ -1,165 +0,0 @@
-import { ChatInfo } from '../../dtos/chatInfo';
-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 { TelegramApiService } from '../telegramApi';
-import { BaseActionProcessor } from './baseProcessor';
-
-export class InlineQueryActionProcessor extends BaseActionProcessor {
-    private inlineQueries!: InlineQueryAction[];
-    /** Fake chat info, since inline queries are chat-less */
-    private readonly fakeChatInfo = new ChatInfo(
-        Math.random(),
-        'Inline Query',
-        []
-    );
-
-    initialize(
-        api: TelegramApiService,
-        telegram: TelegramBot,
-        inlineQueries: InlineQueryAction[],
-        period: Milliseconds
-    ) {
-        this.initializeDependencies(api);
-        this.inlineQueries = inlineQueries;
-
-        let pendingInlineQueries: IncomingInlineQuery[] = [];
-
-        const queriesInProcessing = new Map<number, IncomingInlineQuery>();
-
-        if (this.inlineQueries.length > 0) {
-            telegram.on('inline_query', ({ inlineQuery }) => {
-                const query = new IncomingInlineQuery(
-                    inlineQuery.id,
-                    inlineQuery.query,
-                    inlineQuery.from.id,
-                    createTrace('InlineQuery', this.botName, inlineQuery.id)
-                );
-
-                this.eventEmitter.emit(BotEventType.inlineQueryRecieved, {
-                    query,
-                    traceId: query.traceId
-                });
-
-                const queryBeingProcessed = queriesInProcessing.get(
-                    query.userId
-                );
-                if (queryBeingProcessed) {
-                    this.eventEmitter.emit(
-                        BotEventType.inlineProcessingAborting,
-                        {
-                            newQuery: query,
-                            abortedQuery: queryBeingProcessed,
-                            traceId: query.traceId
-                        }
-                    );
-
-                    queryBeingProcessed.abortController.abort();
-                    queriesInProcessing.delete(query.userId);
-                }
-
-                pendingInlineQueries = pendingInlineQueries.filter(
-                    (q) => q.userId != query.userId
-                );
-
-                pendingInlineQueries.push(query);
-            });
-
-            this.scheduler.createTask(
-                'InlineQueryProcessing',
-                () => {
-                    const queriesToProcess = [...pendingInlineQueries];
-                    pendingInlineQueries = [];
-                    const promises = [];
-
-                    for (const inlineQuery of queriesToProcess) {
-                        this.eventEmitter.emit(
-                            BotEventType.inlineProcessingStarted,
-                            {
-                                botName: this.botName,
-                                traceId: inlineQuery.traceId
-                            }
-                        );
-
-                        queriesInProcessing.set(
-                            inlineQuery.userId,
-                            inlineQuery
-                        );
-
-                        const actionPromises = this.inlineQueries.map(
-                            (inlineQueryAction) => {
-                                const ctx = new InlineQueryContextInternal(
-                                    this.storage,
-                                    this.scheduler,
-                                    this.eventEmitter,
-                                    inlineQueryAction,
-                                    inlineQuery,
-                                    this.fakeChatInfo,
-                                    this.botName
-                                );
-
-                                const { proxy, revoke } = Proxy.revocable(
-                                    ctx,
-                                    {}
-                                );
-
-                                const executePromise = this.executeAction(
-                                    inlineQueryAction,
-                                    proxy,
-                                    (error, _) => {
-                                        if (error.name == 'AbortError') {
-                                            this.eventEmitter.emit(
-                                                BotEventType.inlineProcessingAborted,
-                                                {
-                                                    abortedQuery: inlineQuery,
-                                                    traceId: inlineQuery.traceId
-                                                }
-                                            );
-                                        } else {
-                                            this.eventEmitter.emit(
-                                                BotEventType.error,
-                                                {
-                                                    error,
-                                                    traceId: inlineQuery.traceId
-                                                }
-                                            );
-                                        }
-                                    }
-                                );
-
-                                return executePromise.finally(() => {
-                                    revoke();
-                                    this.api.flushResponses();
-                                });
-                            }
-                        );
-
-                        const queryPromise = Promise.allSettled(
-                            actionPromises
-                        ).then(() => {
-                            queriesInProcessing.delete(inlineQuery.userId);
-                            this.eventEmitter.emit(
-                                BotEventType.inlineProcessingFinished,
-                                {
-                                    botName: this.botName,
-                                    traceId: inlineQuery.traceId
-                                }
-                            );
-                        });
-
-                        promises.push(queryPromise);
-                    }
-
-                    void Promise.allSettled(promises);
-                },
-                period,
-                false,
-                this.botName
-            );
-        }
-    }
-}

package/src/services/actionProcessors/scheduledActionProcessor.ts

@@ -1,136 +0,0 @@
-import moment from 'moment';
-import { ChatInfo } from '../../dtos/chatInfo';
-import { ScheduledAction } from '../../entities/actions/scheduledAction';
-import { ChatContextInternal } from '../../entities/context/chatContext';
-import { secondsToMilliseconds } from '../../helpers/timeConvertions';
-import { createTrace } from '../../helpers/traceFactory';
-import { IActionState } from '../../types/actionState';
-import { IScheduler } from '../../types/scheduler';
-import { IStorageClient } from '../../types/storage';
-import { Seconds, Milliseconds } from '../../types/timeValues';
-import { TelegramApiService } from '../telegramApi';
-import { BaseActionProcessor } from './baseProcessor';
-import { BotEventType, TypedEventEmitter } from '../../types/events';
-
-export class ScheduledActionProcessor extends BaseActionProcessor {
-    private readonly chats: Record<string, number>;
-    private readonly taskTrace = createTrace(
-        this,
-        this.botName,
-        'ScheduledActionsTaskRun'
-    );
-
-    private scheduled!: ScheduledAction<IActionState>[];
-
-    constructor(
-        botName: string,
-        chats: Record<string, number>,
-        storage: IStorageClient,
-        scheduler: IScheduler,
-        eventEmitter: TypedEventEmitter
-    ) {
-        super(botName, storage, scheduler, eventEmitter);
-        this.chats = chats;
-    }
-
-    initialize(
-        api: TelegramApiService,
-        scheduled: ScheduledAction<IActionState>[],
-        period: Seconds
-    ) {
-        this.initializeDependencies(api);
-        this.scheduled = scheduled;
-
-        if (this.scheduled.length > 0) {
-            const now = moment();
-
-            if (now.minute() == 0 && now.second() == 0) {
-                this.scheduler.createTask(
-                    'ScheduledProcessing',
-                    () => {
-                        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',
-                () => {
-                    this.scheduler.createTask(
-                        'ScheduledProcessing',
-                        () => {
-                            this.runScheduled();
-                        },
-                        secondsToMilliseconds(period),
-                        true,
-                        this.botName
-                    );
-                },
-                delay as Milliseconds,
-                this.botName
-            );
-
-            this.runScheduled();
-        }
-    }
-
-    private runScheduled() {
-        this.eventEmitter.emit(BotEventType.scheduledProcessingStarted, {
-            botName: this.botName,
-            traceId: this.taskTrace
-        });
-
-        const promises = Object.entries(this.chats).flatMap(
-            ([chatName, chatId]) => {
-                const chatInfo = new ChatInfo(chatId, chatName, []);
-
-                return this.scheduled.map((scheduledAction) => {
-                    const ctx = new ChatContextInternal<IActionState>(
-                        this.storage,
-                        this.scheduler,
-                        this.eventEmitter,
-                        scheduledAction,
-                        chatInfo,
-                        createTrace(
-                            scheduledAction,
-                            this.botName,
-                            `${scheduledAction.key}-${chatId}`
-                        ),
-                        this.botName
-                    );
-
-                    const { proxy, revoke } = Proxy.revocable(ctx, {});
-
-                    const executePromise = this.executeAction(
-                        scheduledAction,
-                        proxy
-                    );
-
-                    return executePromise.finally(() => {
-                        revoke();
-                        this.api.flushResponses();
-                    });
-                });
-            }
-        );
-
-        void Promise.allSettled(promises).then(() => {
-            this.eventEmitter.emit(BotEventType.scheduledProcessingStarted, {
-                botName: this.botName,
-                traceId: this.taskTrace
-            });
-        });
-    }
-}