chz-telegram-bot 0.2.1 → 0.3.1

package/entities/botInstance.ts

@@ -1,54 +1,27 @@
-import { Telegraf } from 'telegraf';
-import {
-    hoursToSeconds,
-    secondsToMilliseconds
-} from '../helpers/timeConvertions';
-import { Hours, Milliseconds, Seconds } from '../types/timeValues';
+import { Seconds } from '../types/timeValues';
 import { IStorageClient } from '../types/storage';
 import { JsonFileStorage } from '../services/jsonFileStorage';
-import { TelegramApiService } from '../services/telegramApi';
 import { IActionState } from '../types/actionState';
 import { CommandAction } from './actions/commandAction';
 import { ScheduledAction } from './actions/scheduledAction';
 import { JsonLogger } from '../services/jsonLogger';
-import { IncomingMessage } from '../dtos/incomingMessage';
-import moment from 'moment';
-import { ChatContext } from './context/chatContext';
-import { MessageContext } from './context/messageContext';
-import { ChatInfo } from '../dtos/chatInfo';
 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 { IncomingInlineQuery } from '../dtos/incomingQuery';
-import { InlineQueryContext } from './context/inlineQueryContext';
-import { buildHelpCommand } from '../builtin/helpAction';
-import { UserFromGetMe } from 'telegraf/types';
-import {
-    INTERNAL_MESSAGE_TYPE_PREFIX,
-    MessageType
-} from '../types/messageTypes';
-import { IActionWithState } from '../types/statefulAction';
-import { TraceId } from '../types/trace';
+import { ActionProcessingService } from '../services/actionProcessingService';
 
 export class BotInstance {
-    private readonly api: TelegramApiService;
     private readonly storage: IStorageClient;
     private readonly scheduler: IScheduler;
     private readonly logger: ILogger;
-    private readonly telegraf: Telegraf;
+    private readonly actionProcessingService: ActionProcessingService;
 
-    name!: string;
-    private botInfo!: UserFromGetMe;
-    private commands!: CommandAction<IActionState>[];
-    private scheduled!: ScheduledAction<IActionState>[];
-    private inlineQueries!: InlineQueryAction[];
-    private chats!: Record<string, number>;
+    readonly name: string;
 
     constructor(options: {
         name: string;
-        token: string;
         actions: {
             commands: CommandAction<IActionState>[];
             scheduled: ScheduledAction<IActionState>[];
@@ -56,8 +29,6 @@ export class BotInstance {
         };
         chats: Record<string, number>;
         storagePath?: string;
-        scheduledPeriod?: Seconds;
-        verboseLoggingForIncomingMessage?: boolean;
         services?: {
             storageClient?: IStorageClient;
             logger?: ILogger;
@@ -70,9 +41,7 @@ export class BotInstance {
         ];
 
         this.name = options.name;
-        this.chats = options.chats;
 
-        this.telegraf = new Telegraf(options.token);
         this.logger = options.services?.logger ?? new JsonLogger();
         this.scheduler =
             options.services?.scheduler ??
@@ -80,63 +49,34 @@ export class BotInstance {
         this.storage =
             options.services?.storageClient ??
             new JsonFileStorage(options.name, actions, options.storagePath);
-        this.api = new TelegramApiService(
+        this.actionProcessingService = new ActionProcessingService(
             this.name,
-            this.telegraf.telegram,
+            options.chats,
             this.storage,
+            this.scheduler,
             this.logger
         );
 
         this.storage.saveMetadata(actions, this.name);
     }
 
-    async start(options: {
-        name: string;
-        token: string;
+    async start(
+        token: string,
         actions: {
             commands: CommandAction<IActionState>[];
             scheduled: ScheduledAction<IActionState>[];
             inlineQueries: InlineQueryAction[];
-        };
-        chats: Record<string, number>;
-        storagePath?: string;
-        scheduledPeriod?: Seconds;
-        verboseLoggingForIncomingMessage?: boolean;
-        services?: {
-            storageClient?: IStorageClient;
-            logger?: ILogger;
-            scheduler?: IScheduler;
-        };
-    }) {
-        this.botInfo = await this.telegraf.telegram.getMe();
-
-        this.commands =
-            options.actions.commands.length > 0
-                ? [
-                      buildHelpCommand(
-                          options.actions.commands
-                              .map((x) =>
-                                  x.readmeFactory(this.botInfo.username)
-                              )
-                              .filter((x) => !!x),
-                          this.botInfo.username
-                      ),
-                      ...options.actions.commands
-                  ]
-                : [];
-        this.scheduled = options.actions.scheduled;
-        this.inlineQueries = options.actions.inlineQueries;
-
-        this.initializeMessageProcessing(
-            options.verboseLoggingForIncomingMessage ?? false
-        );
-        this.initializeInlineQueryProcessing(1000 as Milliseconds);
-        this.initializeScheduledProcessing(
-            options.scheduledPeriod ?? hoursToSeconds(1 as Hours)
+        },
+        scheduledPeriod?: Seconds,
+        verboseLoggingForIncomingMessage?: boolean
+    ) {
+        this.actionProcessingService.initialize(
+            token,
+            actions,
+            scheduledPeriod,
+            verboseLoggingForIncomingMessage
         );
 
-        this.telegraf.launch();
-
         this.logger.logWithTraceId(
             this.name,
             createTrace(this, this.name, 'Start'),
@@ -145,168 +85,6 @@ export class BotInstance {
         );
     }
 
-    private initializeScheduledProcessing(period: Seconds) {
-        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.name
-                );
-
-                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.name
-                    );
-                },
-                delay as Milliseconds,
-                this.name
-            );
-        }
-    }
-
-    private initializeInlineQueryProcessing(period: Milliseconds) {
-        let pendingInlineQueries: 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.name, ctx.inlineQuery.id)
-                );
-
-                this.logger.logWithTraceId(
-                    this.name,
-                    query.traceId,
-                    'Query',
-                    `${ctx.inlineQuery.from.username} (${ctx.inlineQuery.from.id}): Query for ${ctx.inlineQuery.query}`
-                );
-
-                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) {
-                        for (const inlineQueryAction of this.inlineQueries) {
-                            ctx.initializeContext(
-                                inlineQuery.query,
-                                inlineQuery.queryId,
-                                this.name,
-                                inlineQueryAction,
-                                inlineQuery.traceId
-                            );
-
-                            try {
-                                const responses = await inlineQueryAction.exec(
-                                    ctx
-                                );
-                                this.api.enqueueBatchedResponses(responses);
-                                ctx.isInitialized = false;
-                            } catch (error) {
-                                this.logger.errorWithTraceId(
-                                    ctx.botName,
-                                    ctx.traceId,
-                                    'Unknown',
-                                    error,
-                                    ctx
-                                );
-                            }
-                        }
-                    }
-
-                    this.api.flushResponses();
-                },
-                period,
-                false,
-                this.name
-            );
-        }
-    }
-
-    private initializeMessageProcessing(
-        verboseLoggingForIncomingMessage: boolean
-    ) {
-        if (this.commands.length > 0) {
-            const triggersToBeProcessed = 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.name);
-
-                if (verboseLoggingForIncomingMessage) {
-                    this.logger.logObjectWithTraceId(
-                        this.name,
-                        msg.traceId,
-                        msg.chatInfo.name,
-                        ctx.update.message
-                    );
-                } else {
-                    this.logger.logWithTraceId(
-                        this.name,
-                        msg.traceId,
-                        msg.chatInfo.name,
-                        `${msg.from?.first_name ?? 'Unknown'} (${
-                            msg.from?.id ?? 'Unknown'
-                        }): ${msg.text || `<non-text message: ${msg.type}>`}`
-                    );
-                }
-
-                if (triggersToBeProcessed.has(msg.type))
-                    await this.processMessage(msg);
-            });
-        }
-    }
-
     async stop(code: string) {
         this.logger.logWithTraceId(
             this.name,
@@ -317,112 +95,6 @@ export class BotInstance {
 
         this.scheduler.stopAll();
         await this.storage.close();
-        this.telegraf.stop(code);
-    }
-
-    private initializeMessageContext<TActionState extends IActionState>(
-        ctx: MessageContext<IActionState>,
-        action: IActionWithState<TActionState>,
-        message: IncomingMessage
-    ) {
-        ctx.messageId = message.message_id;
-        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;
-
-        this.initializeChatContext(
-            ctx,
-            action,
-            message.chatInfo,
-            message.traceId
-        );
-    }
-
-    private initializeChatContext<TActionState extends IActionState>(
-        ctx: ChatContext<IActionState>,
-        action: IActionWithState<TActionState>,
-        chatInfo: ChatInfo,
-        traceId: TraceId
-    ) {
-        ctx.responses = [];
-        ctx.isInitialized = true;
-        ctx.botName = this.name;
-        ctx.action = action;
-        ctx.chatInfo = chatInfo;
-        ctx.traceId = traceId;
-    }
-
-    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.name,
-                        `${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 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
-                );
-            }
-        }
-
-        this.api.flushResponses();
+        this.actionProcessingService.stop(code);
     }
 }

package/entities/context/chatContext.ts

@@ -8,15 +8,18 @@ import {
     MessageSendingOptions,
     TextMessageSendingOptions
 } from '../../types/messageSendingOptions';
-import { IActionWithState } from '../../types/statefulAction';
+import { IActionWithState } from '../../types/action';
 import { IActionState } from '../../types/actionState';
-import { BotResponse } from '../../types/response';
+import { BotResponse, IReplyResponse } from '../../types/response';
 import { Milliseconds } from '../../types/timeValues';
 import { DelayResponse } from '../../dtos/responses/delay';
 import { ChatInfo } from '../../dtos/chatInfo';
 import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';
 import { TraceId } from '../../types/trace';
+import { ICaptureController } from '../../types/capture';
+import { CommandTrigger } from '../../types/commandTrigger';
+import { ReplyContext } from './replyContext';
 
 /**
  * Context of action executed in chat.
@@ -52,6 +55,27 @@ export class ChatContext<TActionState extends IActionState> {
         this.scheduler = scheduler;
     }
 
+    protected createCaptureController_TEMP(
+        response: IReplyResponse
+    ): ICaptureController {
+        return {
+            captureReplies: (
+                trigger: CommandTrigger[],
+                handler: (
+                    replyContext: ReplyContext<TActionState>
+                ) => Promise<void>,
+                abortController: AbortController
+            ) => {
+                response.captures.push({
+                    trigger,
+                    handler,
+                    abortController,
+                    action: this.action
+                });
+            }
+        };
+    }
+
     /**
      * Collection of actions that send something to chat as a standalone message.
      */
@@ -63,16 +87,18 @@ export class ChatContext<TActionState extends IActionState> {
          * @param options Message sending option.
          */
         text: (text: string, options?: TextMessageSendingOptions) => {
-            this.responses.push(
-                new TextMessage(
-                    text,
-                    this.chatInfo,
-                    this.traceId,
-                    this.action,
-                    undefined,
-                    options
-                )
+            const response = new TextMessage(
+                text,
+                this.chatInfo,
+                this.traceId,
+                this.action,
+                undefined,
+                options
             );
+
+            this.responses.push(response);
+
+            return this.createCaptureController_TEMP(response);
         },
 
         /**
@@ -82,16 +108,18 @@ export class ChatContext<TActionState extends IActionState> {
          * @param options Message sending option.
          */
         image: (name: string, options?: MessageSendingOptions) => {
-            this.responses.push(
-                new ImageMessage(
-                    { source: resolve(`./content/${name}.png`) },
-                    this.chatInfo,
-                    this.traceId,
-                    this.action,
-                    undefined,
-                    options
-                )
+            const response = new ImageMessage(
+                { source: resolve(`./content/${name}.png`) },
+                this.chatInfo,
+                this.traceId,
+                this.action,
+                undefined,
+                options
             );
+
+            this.responses.push(response);
+
+            return this.createCaptureController_TEMP(response);
         },
 
         /**
@@ -101,16 +129,18 @@ export class ChatContext<TActionState extends IActionState> {
          * @param options Message sending option.
          */
         video: (name: string, options?: MessageSendingOptions) => {
-            this.responses.push(
-                new VideoMessage(
-                    { source: resolve(`./content/${name}.mp4`) },
-                    this.chatInfo,
-                    this.traceId,
-                    this.action,
-                    undefined,
-                    options
-                )
+            const response = new VideoMessage(
+                { source: resolve(`./content/${name}.mp4`) },
+                this.chatInfo,
+                this.traceId,
+                this.action,
+                undefined,
+                options
             );
+
+            this.responses.push(response);
+
+            return this.createCaptureController_TEMP(response);
         }
     };
 

package/entities/context/inlineQueryContext.ts

@@ -8,8 +8,8 @@ import { InlineQueryAction } from '../actions/inlineQueryAction';
 import { InlineQueryResponse } from '../../dtos/responses/inlineQueryResponse';
 
 export class InlineQueryContext {
-    private action!: InlineQueryAction;
-    private queryResults: InlineQueryResult[] = [];
+    action!: InlineQueryAction;
+    queryResults: InlineQueryResult[] = [];
 
     /** Storage client instance for the bot executing this action. */
     readonly storage: IStorageClient;
@@ -22,6 +22,11 @@ export class InlineQueryContext {
     traceId!: TraceId;
     /** Name of a bot that executes this action. */
     botName!: string;
+    /**
+     * Abort signal to be utilized in query handler.
+     * Signal will be aborted if new query comes from the same user.
+     */
+    abortSignal!: AbortSignal;
 
     /** Ordered collection of responses to be processed  */
     get responses(): BotResponse[] {
@@ -53,26 +58,6 @@ export class InlineQueryContext {
         this.scheduler = scheduler;
     }
 
-    initializeContext(
-        queryText: string,
-        queryId: string,
-        botName: string,
-        action: InlineQueryAction,
-        traceId: TraceId
-    ) {
-        this.queryText = queryText;
-        this.queryId = queryId;
-        this.botName = botName;
-        this.action = action;
-        this.traceId = traceId;
-
-        this.isInitialized = true;
-        this.queryResults = [];
-        this.matchResults = [];
-
-        return this;
-    }
-
     /**
      * This result will be shown to user as a response to inline query.
      * @param queryResult Inline query result to be shown to user.