chz-telegram-bot 0.1.20 → 0.2.1

package/dtos/responses/videoMessage.ts

@@ -1,18 +1,19 @@
 import { InputFile } from 'telegraf/types';
-import { BotResponseTypes, IReplyMessage } from '../../types/response';
+import { BotResponseTypes, IReplyResponse } from '../../types/response';
 import { MessageSendingOptions } from '../../types/messageSendingOptions';
 import { IActionWithState } from '../../types/statefulAction';
 import { IActionState } from '../../types/actionState';
 import { ChatInfo } from '../chatInfo';
 import { TraceId } from '../../types/trace';
+import { ReplyInfo } from '../../types/replyInfo';
 
-export class VideoMessage implements IReplyMessage<InputFile> {
+export class VideoMessage implements IReplyResponse<InputFile> {
     readonly kind = BotResponseTypes.video;
     readonly createdAt = Date.now();
 
     readonly content: InputFile;
     readonly chatInfo: ChatInfo;
-    readonly replyId: number | undefined;
+    readonly replyInfo: ReplyInfo | undefined;
     readonly traceId: TraceId;
     readonly disableWebPreview = false;
     readonly shouldPin: boolean;
@@ -21,14 +22,14 @@ export class VideoMessage implements IReplyMessage<InputFile> {
     constructor(
         video: InputFile,
         chatInfo: ChatInfo,
-        replyId: number | undefined,
         traceId: TraceId,
         action: IActionWithState<IActionState>,
+        replyInfo: ReplyInfo | undefined,
         options?: MessageSendingOptions
     ) {
         this.content = video;
         this.chatInfo = chatInfo;
-        this.replyId = replyId;
+        this.replyInfo = replyInfo;
         this.traceId = traceId;
         this.shouldPin = options?.pin ?? false;
         this.action = action;

package/entities/botInstance.ts

@@ -29,6 +29,8 @@ import {
     INTERNAL_MESSAGE_TYPE_PREFIX,
     MessageType
 } from '../types/messageTypes';
+import { IActionWithState } from '../types/statefulAction';
+import { TraceId } from '../types/trace';
 
 export class BotInstance {
     private readonly api: TelegramApiService;
@@ -318,6 +320,45 @@ export class BotInstance {
         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,
@@ -327,8 +368,8 @@ export class BotInstance {
 
         for (const [chatName, chatId] of Object.entries(this.chats)) {
             for (const scheduledAction of this.scheduled) {
-                ctx.initializeChatContext(
-                    this.name,
+                this.initializeChatContext(
+                    ctx,
                     scheduledAction,
                     new ChatInfo(chatId, chatName),
                     createTrace(
@@ -365,7 +406,7 @@ export class BotInstance {
         );
 
         for (const commandAction of this.commands) {
-            ctx.initializeMessageContext(this.name, commandAction, msg);
+            this.initializeMessageContext(ctx, commandAction, msg);
 
             try {
                 const responses = await commandAction.exec(ctx);

package/entities/context/chatContext.ts

@@ -22,7 +22,7 @@ import { TraceId } from '../../types/trace';
  * Context of action executed in chat.
  */
 export class ChatContext<TActionState extends IActionState> {
-    protected action!: IActionWithState<TActionState>;
+    action!: IActionWithState<TActionState>;
 
     /** Storage client instance for the bot executing this action. */
     readonly storage: IStorageClient;
@@ -52,81 +52,67 @@ export class ChatContext<TActionState extends IActionState> {
         this.scheduler = scheduler;
     }
 
-    initializeChatContext(
-        botName: string,
-        action: IActionWithState<TActionState>,
-        chatInfo: ChatInfo,
-        traceId: TraceId
-    ) {
-        this.botName = botName;
-        this.action = action;
-        this.chatInfo = chatInfo;
-        this.traceId = traceId;
-
-        this.isInitialized = true;
-        this.responses = [];
-
-        return this;
-    }
-
     /**
-     * Sends text message to chat 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.
+     * Collection of actions that send something to chat as a standalone message.
      */
-    sendTextToChat(text: string, options?: TextMessageSendingOptions) {
-        this.responses.push(
-            new TextMessage(
-                text,
-                this.chatInfo,
-                undefined,
-                this.traceId,
-                this.action,
-                options
-            )
-        );
-    }
+    send = {
+        /**
+         * Sends text message to chat 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.
+         */
+        text: (text: string, options?: TextMessageSendingOptions) => {
+            this.responses.push(
+                new TextMessage(
+                    text,
+                    this.chatInfo,
+                    this.traceId,
+                    this.action,
+                    undefined,
+                    options
+                )
+            );
+        },
 
-    /**
-     * Sends image message to chat 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 name Message contents.
-     * @param options Message sending option.
-     */
-    sendImageToChat(name: string, options?: MessageSendingOptions) {
-        const filePath = `./content/${name}.png`;
-        this.responses.push(
-            new ImageMessage(
-                { source: resolve(filePath) },
-                this.chatInfo,
-                undefined,
-                this.traceId,
-                this.action,
-                options
-            )
-        );
-    }
+        /**
+         * Sends image message to chat 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 name Message contents.
+         * @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
+                )
+            );
+        },
 
-    /**
-     * Sends video/gif message to chat 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 name Message contents.
-     * @param options Message sending option.
-     */
-    sendVideoToChat(name: string, options?: MessageSendingOptions) {
-        const filePath = `./content/${name}.mp4`;
-        this.responses.push(
-            new VideoMessage(
-                { source: resolve(filePath) },
-                this.chatInfo,
-                undefined,
-                this.traceId,
-                this.action,
-                options
-            )
-        );
-    }
+        /**
+         * Sends video/gif message to chat 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 name Message contents.
+         * @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
+                )
+            );
+        }
+    };
 
     /**
      * Unpins message after action execution is finished.

package/entities/context/messageContext.ts

@@ -8,18 +8,18 @@ import { TextMessage } from '../../dtos/responses/textMessage';
 import { VideoMessage } from '../../dtos/responses/videoMessage';
 import { ActionStateBase } from '../states/actionStateBase';
 import { ChatContext } from './chatContext';
-import { IncomingMessage } from '../../dtos/incomingMessage';
 import {
     MessageSendingOptions,
     TextMessageSendingOptions
 } from '../../types/messageSendingOptions';
-import { IActionWithState, ActionKey } from '../../types/statefulAction';
+import { ActionKey } from '../../types/statefulAction';
 import {
     MessageTypeValue,
     TelegrafContextMessage
 } from '../../types/messageTypes';
 import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';
+import { ReplyInfo } from '../../types/replyInfo';
 /**
  * Context of action executed in chat, in response to a message
  */
@@ -51,126 +51,171 @@ export class MessageContext<
         super(storage, logger, scheduler);
     }
 
-    initializeMessageContext(
-        botName: string,
-        action: IActionWithState<TActionState>,
-        message: IncomingMessage
+    private replyWithText(
+        text: string,
+        quote: boolean,
+        options?: TextMessageSendingOptions
     ) {
-        this.messageId = message.message_id;
-        this.messageText = message.text ?? '';
-        this.messageType = message.type;
-        this.fromUserId = message.from?.id;
-        this.fromUserName =
-            (message.from?.first_name ?? 'Unknown user') +
-            (message.from?.last_name ? ` ${message.from.last_name}` : '');
-        this.messageUpdateObject = message.updateObject;
+        const quotedPart =
+            this.matchResults.length != 0
+                ? this.matchResults[0][1]
+                : this.messageText;
 
-        this.matchResults = [];
-        this.startCooldown = true;
-
-        return this.initializeChatContext(
-            botName,
-            action,
-            message.chatInfo,
-            message.traceId
-        );
-    }
-
-    /**
-     * Loads state of another action. Changes to the loaded state will no affect actual state of other action.
-     * @param commandName Name of an action to load state of.
-     * @template TAnotherActionState - Type of a state that is used by another action.
-     */
-    async loadStateOf<TAnotherActionState extends IActionState>(
-        commandName: string
-    ): Promise<TAnotherActionState> {
-        const storageKey = `command:${commandName.replace(
-            '.',
-            '-'
-        )}` as ActionKey;
-        const allStates = await this.storage.load(storageKey);
-        const stateForChat = allStates[this.chatInfo.id];
-
-        if (!stateForChat) {
-            return new ActionStateBase() as TAnotherActionState;
-        }
-
-        return stateForChat as TAnotherActionState;
-    }
-
-    /**
-     * 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.
-     */
-    replyWithText(text: string, options?: TextMessageSendingOptions) {
         this.responses.push(
             new TextMessage(
                 text,
                 this.chatInfo,
-                this.messageId,
                 this.traceId,
                 this.action,
+                new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
                 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.
-     */
-    replyWithImage(name: string, options?: MessageSendingOptions) {
-        const filePath = `./content/${name}.png`;
+    private replyWithImage(
+        name: string,
+        quote: boolean,
+        options?: MessageSendingOptions
+    ) {
+        const quotedPart =
+            this.matchResults.length != 0
+                ? this.matchResults[0][1]
+                : this.messageText;
+
         this.responses.push(
             new ImageMessage(
-                { source: resolve(filePath) },
+                { source: resolve(`./content/${name}.png`) },
                 this.chatInfo,
-                this.messageId,
                 this.traceId,
                 this.action,
+                new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
                 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.
-     */
-    replyWithVideo(name: string, options?: MessageSendingOptions) {
-        const filePath = `./content/${name}.mp4`;
+    private replyWithVideo(
+        name: string,
+        quote: boolean,
+        options?: MessageSendingOptions
+    ) {
+        const quotedPart =
+            this.matchResults.length != 0
+                ? this.matchResults[0][1]
+                : this.messageText;
+
         this.responses.push(
             new VideoMessage(
-                { source: resolve(filePath) },
+                { source: resolve(`./content/${name}.mp4`) },
                 this.chatInfo,
-                this.messageId,
                 this.traceId,
                 this.action,
+                new ReplyInfo(this.messageId, quote ? quotedPart : undefined),
                 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.
+     * Loads state of another action. Changes to the loaded state will no affect actual state of other action.
+     * @param commandName Name of an action to load state of.
+     * @template TAnotherActionState - Type of a state that is used by another action.
      */
-    react(emoji: TelegramEmoji) {
-        this.responses.push(
-            new Reaction(
-                this.traceId,
-                this.chatInfo,
-                this.messageId,
-                emoji,
-                this.action
-            )
-        );
+    async loadStateOf<TAnotherActionState extends IActionState>(
+        commandName: string
+    ): Promise<TAnotherActionState> {
+        const storageKey = `command:${commandName.replace(
+            '.',
+            '-'
+        )}` as ActionKey;
+        const allStates = await this.storage.load(storageKey);
+        const stateForChat = allStates[this.chatInfo.id];
+
+        if (!stateForChat) {
+            return new ActionStateBase() as TAnotherActionState;
+        }
+
+        return stateForChat as TAnotherActionState;
     }
+
+    /**
+     * 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/package.json

@@ -1,29 +1,30 @@
-{
-    "name": "chz-telegram-bot",
-    "version": "0.1.20",
-    "type": "module",
-    "dependencies": {
-        "async-sema": "^3.1.1",
-        "moment": "^2.29.4",
-        "telegraf": "^4.16.3"
-    },
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "devDependencies": {
-        "@eslint/js": "^9.10.0",
-        "@types/markdown-escape": "^1.1.3",
-        "@types/node": "^22.5.5",
-        "eslint": "^9.10.0",
-        "typescript": "^5.6.2",
-        "typescript-eslint": "^8.5.0"
-    },
-    "scripts": {
-        "build": "tsc",
-        "lint": "npx eslint && tsc --noEmit"
-    },
-    "overrides": {
-        "telegraf": {
-            "node-fetch": "3.3.2"
-        }
-    }
-}
+{
+    "name": "chz-telegram-bot",
+    "version": "0.2.1",
+    "type": "module",
+    "dependencies": {
+        "async-sema": "^3.1.1",
+        "moment": "^2.29.4",
+        "telegraf": "^4.16.3"
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "devDependencies": {
+        "@eslint/js": "^9.29.0",
+        "@types/markdown-escape": "^1.1.3",
+        "@types/node": "^22.5.5",
+        "eslint": "^9.29.0",
+        "globals": "^16.2.0",
+        "typescript": "^5.6.2",
+        "typescript-eslint": "^8.34.1"
+    },
+    "scripts": {
+        "build": "tsc",
+        "lint": "npx eslint && tsc --noEmit"
+    },
+    "overrides": {
+        "telegraf": {
+            "node-fetch": "3.3.2"
+        }
+    }
+}