chz-telegram-bot 0.2.1 → 0.3.0

package/entities/context/messageContext.ts

@@ -12,14 +12,15 @@ import {
     MessageSendingOptions,
     TextMessageSendingOptions
 } from '../../types/messageSendingOptions';
-import { ActionKey } from '../../types/statefulAction';
+import { ActionKey } from '../../types/action';
 import {
     MessageTypeValue,
     TelegrafContextMessage
 } from '../../types/messageTypes';
 import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';
-import { ReplyInfo } from '../../types/replyInfo';
+import { ReplyInfo } from '../../dtos/replyInfo';
+
 /**
  * Context of action executed in chat, in response to a message
  */
@@ -61,16 +62,18 @@ export class MessageContext<
                 ? this.matchResults[0][1]
                 : this.messageText;
 
-        this.responses.push(
-            new TextMessage(
-                text,
-                this.chatInfo,
-                this.traceId,
-                this.action,
-                new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
-                options
-            )
+        const response = new TextMessage(
+            text,
+            this.chatInfo,
+            this.traceId,
+            this.action,
+            new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
+            options
         );
+
+        this.responses.push(response);
+
+        return this.createCaptureController_TEMP(response);
     }
 
     private replyWithImage(
@@ -83,16 +86,18 @@ export class MessageContext<
                 ? this.matchResults[0][1]
                 : this.messageText;
 
-        this.responses.push(
-            new ImageMessage(
-                { source: resolve(`./content/${name}.png`) },
-                this.chatInfo,
-                this.traceId,
-                this.action,
-                new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
-                options
-            )
+        const response = new ImageMessage(
+            { source: resolve(`./content/${name}.png`) },
+            this.chatInfo,
+            this.traceId,
+            this.action,
+            new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
+            options
         );
+
+        this.responses.push(response);
+
+        return this.createCaptureController_TEMP(response);
     }
 
     private replyWithVideo(
@@ -105,16 +110,18 @@ export class MessageContext<
                 ? this.matchResults[0][1]
                 : this.messageText;
 
-        this.responses.push(
-            new VideoMessage(
-                { source: resolve(`./content/${name}.mp4`) },
-                this.chatInfo,
-                this.traceId,
-                this.action,
-                new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
-                options
-            )
+        const response = new VideoMessage(
+            { source: resolve(`./content/${name}.mp4`) },
+            this.chatInfo,
+            this.traceId,
+            this.action,
+            new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
+            options
         );
+
+        this.responses.push(response);
+
+        return this.createCaptureController_TEMP(response);
     }
 
     /**

package/entities/context/replyContext.ts

@@ -0,0 +1,225 @@
+import { TelegramEmoji } from 'telegraf/types';
+import { ChatInfo } from '../../dtos/chatInfo';
+import { ReplyInfo } from '../../dtos/replyInfo';
+import { ImageMessage } from '../../dtos/responses/imageMessage';
+import { Reaction } from '../../dtos/responses/reaction';
+import { TextMessage } from '../../dtos/responses/textMessage';
+import { VideoMessage } from '../../dtos/responses/videoMessage';
+import { IActionState } from '../../types/actionState';
+import { ILogger } from '../../types/logger';
+import {
+    TextMessageSendingOptions,
+    MessageSendingOptions
+} from '../../types/messageSendingOptions';
+import {
+    MessageTypeValue,
+    TelegrafContextMessage
+} from '../../types/messageTypes';
+import { BotResponse } from '../../types/response';
+import { IScheduler } from '../../types/scheduler';
+import { IStorageClient } from '../../types/storage';
+import { TraceId } from '../../types/trace';
+import { ReplyCaptureAction } from '../actions/replyCaptureAction';
+import { resolve } from 'path';
+
+export class ReplyContext<TParentActionState extends IActionState> {
+    action!: ReplyCaptureAction<TParentActionState>;
+
+    /** Storage client instance for the bot executing this action. */
+    readonly storage: IStorageClient;
+    /** Logger instance for the bot executing this action */
+    readonly logger: ILogger;
+    /** Scheduler instance for the bot executing this action */
+    readonly scheduler: IScheduler;
+
+    /** Trace id of a action execution. */
+    traceId!: TraceId;
+    /** Name of a bot that executes this action. */
+    botName!: string;
+
+    /** Ordered collection of responses to be processed  */
+    responses: BotResponse[] = [];
+    /** Chat information. */
+    chatInfo!: ChatInfo;
+    /** Collection of Regexp match results on a message that triggered this action. Will be empty if trigger is not a Regexp. */
+    matchResults!: RegExpExecArray[];
+    /** Id of a message that triggered this action. */
+    replyMessageId!: number | undefined;
+    /** Id of a message that triggered this action. */
+    messageId!: number;
+    /** Type of message being received */
+    messageType!: MessageTypeValue;
+    /** Text of a message that triggered this action. */
+    messageText!: string;
+    /** Id of a user that sent a message that triggered this action. */
+    fromUserId: number | undefined;
+    /** Name of a user that sent a message that triggered this action. */
+    fromUserName!: string;
+    /** Message object recieved from Telegram */
+    messageUpdateObject!: TelegrafContextMessage;
+
+    isInitialized = false;
+
+    constructor(
+        storage: IStorageClient,
+        logger: ILogger,
+        scheduler: IScheduler
+    ) {
+        this.storage = storage;
+        this.logger = logger;
+        this.scheduler = scheduler;
+    }
+
+    private replyWithText(
+        text: string,
+        quote: boolean,
+        options?: TextMessageSendingOptions
+    ) {
+        const quotedPart =
+            this.matchResults.length != 0
+                ? this.matchResults[0][1]
+                : this.messageText;
+
+        const response = new TextMessage(
+            text,
+            this.chatInfo,
+            this.traceId,
+            this.action,
+            new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
+            options
+        );
+
+        this.responses.push(response);
+    }
+
+    private replyWithImage(
+        name: string,
+        quote: boolean,
+        options?: MessageSendingOptions
+    ) {
+        const quotedPart =
+            this.matchResults.length != 0
+                ? this.matchResults[0][1]
+                : this.messageText;
+
+        const response = new ImageMessage(
+            { source: resolve(`./content/${name}.png`) },
+            this.chatInfo,
+            this.traceId,
+            this.action,
+            new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
+            options
+        );
+
+        this.responses.push(response);
+    }
+
+    private replyWithVideo(
+        name: string,
+        quote: boolean,
+        options?: MessageSendingOptions
+    ) {
+        const quotedPart =
+            this.matchResults.length != 0
+                ? this.matchResults[0][1]
+                : this.messageText;
+
+        const response = new VideoMessage(
+            { source: resolve(`./content/${name}.mp4`) },
+            this.chatInfo,
+            this.traceId,
+            this.action,
+            new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
+            options
+        );
+
+        this.responses.push(response);
+    }
+
+    /**
+     * Stops capturing replies and removes this action
+     */
+    stopCapture() {
+        this.action.abortController.abort();
+    }
+
+    /**
+     * Collection of actions that can be done as a reply to a message that triggered this action
+     */
+    reply = {
+        /**
+         * Collection of actions that can be done as a reply to a message, quoting the part that triggered this action
+         * If regex is matched, first match will be quoted
+         */
+        andQuote: {
+            /**
+             * Reply with text message to message that triggered this action after action execution is finished.
+             * If multiple responses are sent, they will be sent in the order they were added, with delay of at least 35ms as per Telegram rate-limit.
+             * @param text Message contents.
+             * @param options Message sending option.
+             */
+            withText: (text: string, options?: TextMessageSendingOptions) =>
+                this.replyWithText(text, true, options),
+            /**
+             * Reply with image message to message that triggered this action after action execution is finished.
+             * If multiple responses are sent, they will be sent in the order they were added, with delay of at least 35ms as per Telegram rate-limit.
+             * @param text Message contents.
+             * @param options Message sending option.
+             */
+            withImage: (name: string, options?: MessageSendingOptions) =>
+                this.replyWithImage(name, true, options),
+
+            /**
+             * Reply with video/gif message to message that triggered this action after action execution is finished.
+             * If multiple responses are sent, they will be sent in the order they were added, with delay of at least 35ms as per Telegram rate-limit.
+             * @param text Message contents.
+             * @param options Message sending option.
+             */
+            withVideo: (name: string, options?: MessageSendingOptions) =>
+                this.replyWithVideo(name, true, options)
+        },
+
+        /**
+         * Reply with text message to message that triggered this action after action execution is finished.
+         * If multiple responses are sent, they will be sent in the order they were added, with delay of at least 35ms as per Telegram rate-limit.
+         * @param text Message contents.
+         * @param options Message sending option.
+         */
+        withText: (text: string, options?: TextMessageSendingOptions) =>
+            this.replyWithText(text, false, options),
+        /**
+         * Reply with image message to message that triggered this action after action execution is finished.
+         * If multiple responses are sent, they will be sent in the order they were added, with delay of at least 35ms as per Telegram rate-limit.
+         * @param text Message contents.
+         * @param options Message sending option.
+         */
+        withImage: (name: string, options?: MessageSendingOptions) =>
+            this.replyWithImage(name, false, options),
+
+        /**
+         * Reply with video/gif message to message that triggered this action after action execution is finished.
+         * If multiple responses are sent, they will be sent in the order they were added, with delay of at least 35ms as per Telegram rate-limit.
+         * @param text Message contents.
+         * @param options Message sending option.
+         */
+        withVideo: (name: string, options?: MessageSendingOptions) =>
+            this.replyWithVideo(name, false, options),
+
+        /**
+         * React to the message that triggered this action after action execution is finished.
+         * If multiple responses are sent, they will be sent in the order they were added, with delay of at least 35ms as per Telegram rate-limit.
+         * @param emoji Telegram emoji to react with.
+         */
+        withReaction: (emoji: TelegramEmoji) => {
+            this.responses.push(
+                new Reaction(
+                    this.traceId,
+                    this.chatInfo,
+                    this.messageId,
+                    emoji,
+                    this.action
+                )
+            );
+        }
+    };
+}

package/main.ts

@@ -46,24 +46,25 @@ class BotOrchestrator {
         };
     }) {
         const token = await readFile(options.tokenFilePath, 'utf8');
-        const remappedOptions = {
+
+        const bot = new BotInstance({
             name: options.name,
-            token,
             actions: options.actions,
             chats: options.chats,
-            storagePath: options.storagePath,
-            scheduledPeriod: options.scheduledPeriod,
-            verboseLoggingForIncomingMessage:
-                options.verboseLoggingForIncomingMessage,
             services: {
                 storageClient: options.services?.storageClient,
                 logger: options.services?.logger,
                 scheduler: options.services?.scheduler
-            }
-        };
-        const bot = new BotInstance(remappedOptions);
+            },
+            storagePath: options.storagePath
+        });
 
-        await bot.start(remappedOptions);
+        await bot.start(
+            token,
+            options.actions,
+            options.scheduledPeriod,
+            options.verboseLoggingForIncomingMessage
+        );
         this.bots.push(bot);
 
         return bot;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "chz-telegram-bot",
-    "version": "0.2.1",
+    "version": "0.3.0",
     "type": "module",
     "dependencies": {
         "async-sema": "^3.1.1",

package/services/actionProcessingService.ts

@@ -0,0 +1,123 @@
+import { hoursToSeconds } from '../helpers/timeConvertions';
+import { Seconds, Milliseconds, Hours } from '../types/timeValues';
+import { Telegraf } from 'telegraf';
+import { ILogger } from '../types/logger';
+import { IScheduler } from '../types/scheduler';
+import { IStorageClient } from '../types/storage';
+import { TelegramApiService } from './telegramApi';
+import { InlineQueryAction } from '../entities/actions/inlineQueryAction';
+import { IActionState } from '../types/actionState';
+import { CommandAction } from '../entities/actions/commandAction';
+import { ScheduledAction } from '../entities/actions/scheduledAction';
+import { buildHelpCommand } from '../builtin/helpAction';
+import { CommandActionProcessor } from './actionProcessors/commandActionProcessor';
+import { InlineQueryActionProcessor } from './actionProcessors/inlineQueryActionProcessor';
+import { ScheduledActionProcessor } from './actionProcessors/scheduledActionProcessor';
+
+export class ActionProcessingService {
+    private readonly storage: IStorageClient;
+    private readonly logger: ILogger;
+
+    private readonly commandProcessor: CommandActionProcessor;
+    private readonly scheduledProcessor: ScheduledActionProcessor;
+    private readonly inlineQueryProcessor: InlineQueryActionProcessor;
+
+    private readonly botName: string;
+
+    private telegraf!: Telegraf;
+
+    constructor(
+        botName: string,
+        chats: Record<string, number>,
+        storage: IStorageClient,
+        scheduler: IScheduler,
+        logger: ILogger
+    ) {
+        this.storage = storage;
+        this.logger = logger;
+
+        this.commandProcessor = new CommandActionProcessor(
+            botName,
+            storage,
+            scheduler,
+            logger
+        );
+        this.scheduledProcessor = new ScheduledActionProcessor(
+            botName,
+            chats,
+            storage,
+            scheduler,
+            logger
+        );
+        this.inlineQueryProcessor = new InlineQueryActionProcessor(
+            botName,
+            storage,
+            scheduler,
+            logger
+        );
+
+        this.botName = botName;
+    }
+
+    async initialize(
+        token: string,
+        actions: {
+            commands: CommandAction<IActionState>[];
+            scheduled: ScheduledAction<IActionState>[];
+            inlineQueries: InlineQueryAction[];
+        },
+        scheduledPeriod?: Seconds,
+        verboseLoggingForIncomingMessage?: boolean
+    ) {
+        this.telegraf = new Telegraf(token);
+        const api = new TelegramApiService(
+            this.botName,
+            this.telegraf.telegram,
+            this.storage,
+            this.logger,
+            (capture, id, chatInfo, traceId) =>
+                this.commandProcessor.captureRegistrationCallback(
+                    capture,
+                    id,
+                    chatInfo,
+                    traceId
+                )
+        );
+
+        const botInfo = await this.telegraf.telegram.getMe();
+
+        this.commandProcessor.initialize(
+            api,
+            this.telegraf,
+            actions.commands.length > 0
+                ? [
+                      buildHelpCommand(
+                          actions.commands
+                              .map((x) => x.readmeFactory(botInfo.username))
+                              .filter((x) => !!x),
+                          botInfo.username
+                      ),
+                      ...actions.commands
+                  ]
+                : [],
+            verboseLoggingForIncomingMessage ?? false
+        );
+        this.inlineQueryProcessor.initialize(
+            api,
+            this.telegraf,
+            actions.inlineQueries,
+            300 as Milliseconds
+        );
+        this.scheduledProcessor.initialize(
+            api,
+            actions.scheduled,
+            scheduledPeriod ?? hoursToSeconds(1 as Hours)
+        );
+
+        this.telegraf.launch();
+    }
+
+    stop(code: string) {
+        this.telegraf.stop(code);
+    }
+}