chz-telegram-bot 0.0.49 → 0.0.51

package/{entities → dtos}/incomingMessage.ts

@@ -1,13 +1,13 @@
-import { Chat, Message, Update, User } from 'telegraf/types';
+import { Message, Update, User } from 'telegraf/types';
 import { randomInt } from 'crypto';
 import { MessageType, MessageTypeValue } from '../types/messageTypes';
+import { ChatInfo } from './chatInfo';
 
 export class IncomingMessage {
     message_id: number;
-    chat: Chat;
+    chatInfo: ChatInfo;
     from: User | undefined;
     text: string;
-    chatName: string;
     type: MessageTypeValue;
     traceId = randomInt(10000, 99999);
 
@@ -31,13 +31,14 @@ export class IncomingMessage {
 
     constructor(ctxMessage: Update.New & (Update.NonChannel & Message)) {
         this.message_id = ctxMessage.message_id;
-        this.chat = ctxMessage.chat;
         this.from = ctxMessage.from;
         this.text = 'text' in ctxMessage ? ctxMessage.text : '';
-        this.type = this.detectMessageType(ctxMessage);
-        this.chatName =
+        this.chatInfo = new ChatInfo(
+            ctxMessage.chat.id,
             'title' in ctxMessage.chat
                 ? ctxMessage.chat.title + ' ' + ctxMessage.chat.id
-                : 'DM';
+                : 'DM'
+        );
+        this.type = this.detectMessageType(ctxMessage);
     }
 }

package/{entities → dtos}/responses/delay.ts

@@ -2,22 +2,23 @@ import { IActionState } from '../../types/actionState';
 import { IActionWithState } from '../../types/actionWithState';
 import { BotResponseTypes, IChatResponse } from '../../types/response';
 import { Milliseconds } from '../../types/timeValues';
+import { ChatInfo } from '../chatInfo';
 
 export class DelayResponse implements IChatResponse {
-    kind = BotResponseTypes.delay;
+    readonly kind = BotResponseTypes.delay;
 
-    chatId: number;
-    traceId: number | string;
-    delay: Milliseconds;
-    action: IActionWithState<IActionState>;
+    readonly chatInfo: ChatInfo;
+    readonly traceId: number | string;
+    readonly delay: Milliseconds;
+    readonly action: IActionWithState<IActionState>;
 
     constructor(
         delay: Milliseconds,
-        chatId: number,
+        chatInfo: ChatInfo,
         traceId: number | string,
         action: IActionWithState<IActionState>
     ) {
-        this.chatId = chatId;
+        this.chatInfo = chatInfo;
         this.delay = delay;
         this.traceId = traceId;
         this.action = action;

package/{entities → dtos}/responses/imageMessage.ts

@@ -3,28 +3,29 @@ import { BotResponseTypes, IReplyMessage } from '../../types/response';
 import { MessageSendingOptions } from '../../types/messageSendingOptions';
 import { IActionWithState } from '../../types/actionWithState';
 import { IActionState } from '../../types/actionState';
+import { ChatInfo } from '../chatInfo';
 
 export class ImageMessage implements IReplyMessage<InputFile> {
-    kind = BotResponseTypes.image;
+    readonly kind = BotResponseTypes.image;
 
-    content: InputFile;
-    chatId: number;
-    replyId: number | undefined;
-    traceId: string | number;
-    disableWebPreview = false;
-    shouldPin: boolean;
-    action: IActionWithState<IActionState>;
+    readonly content: InputFile;
+    readonly chatInfo: ChatInfo;
+    readonly replyId: number | undefined;
+    readonly traceId: string | number;
+    readonly disableWebPreview = false;
+    readonly shouldPin: boolean;
+    readonly action: IActionWithState<IActionState>;
 
     constructor(
         image: InputFile,
-        chatId: number,
+        chatInfo: ChatInfo,
         replyId: number | undefined,
         traceId: number | string,
         action: IActionWithState<IActionState>,
         options?: MessageSendingOptions
     ) {
         this.content = image;
-        this.chatId = chatId;
+        this.chatInfo = chatInfo;
         this.replyId = replyId;
         this.traceId = traceId;
         this.shouldPin = options?.pin ?? false;

package/{entities → dtos}/responses/reaction.ts

@@ -2,24 +2,25 @@ import { TelegramEmoji } from 'telegraf/types';
 import { BotResponseTypes, IChatResponse } from '../../types/response';
 import { IActionWithState } from '../../types/actionWithState';
 import { IActionState } from '../../types/actionState';
+import { ChatInfo } from '../chatInfo';
 
 export class Reaction implements IChatResponse {
-    kind = BotResponseTypes.react;
+    readonly kind = BotResponseTypes.react;
 
-    chatId: number;
-    messageId: number;
-    traceId: number | string;
-    emoji: TelegramEmoji;
-    action: IActionWithState<IActionState>;
+    readonly chatInfo: ChatInfo;
+    readonly messageId: number;
+    readonly traceId: number | string;
+    readonly emoji: TelegramEmoji;
+    readonly action: IActionWithState<IActionState>;
 
     constructor(
         traceId: number | string,
-        chatId: number,
+        chatInfo: ChatInfo,
         messageId: number,
         emoji: TelegramEmoji,
         action: IActionWithState<IActionState>
     ) {
-        this.chatId = chatId;
+        this.chatInfo = chatInfo;
         this.messageId = messageId;
         this.emoji = emoji;
         this.traceId = traceId;

package/{entities → dtos}/responses/textMessage.ts

@@ -2,28 +2,29 @@ import { TextMessageSendingOptions } from '../../types/messageSendingOptions';
 import { BotResponseTypes, IReplyMessage } from '../../types/response';
 import { IActionWithState } from '../../types/actionWithState';
 import { IActionState } from '../../types/actionState';
+import { ChatInfo } from '../chatInfo';
 
 export class TextMessage implements IReplyMessage<string> {
-    kind = BotResponseTypes.text;
+    readonly kind = BotResponseTypes.text;
 
-    content: string;
-    chatId: number;
-    replyId: number | undefined;
-    traceId: string | number;
-    disableWebPreview: boolean;
-    shouldPin: boolean;
-    action: IActionWithState<IActionState>;
+    readonly content: string;
+    readonly chatInfo: ChatInfo;
+    readonly replyId: number | undefined;
+    readonly traceId: string | number;
+    readonly disableWebPreview: boolean;
+    readonly shouldPin: boolean;
+    readonly action: IActionWithState<IActionState>;
 
     constructor(
         text: string,
-        chatId: number,
+        chatInfo: ChatInfo,
         replyId: number | undefined,
         traceId: string | number,
         action: IActionWithState<IActionState>,
         options?: TextMessageSendingOptions
     ) {
         this.content = text;
-        this.chatId = chatId;
+        this.chatInfo = chatInfo;
         this.replyId = replyId;
         this.traceId = traceId;
         this.disableWebPreview = options?.disableWebPreview ?? false;

package/{entities → dtos}/responses/unpin.ts

@@ -1,23 +1,24 @@
 import { BotResponseTypes, IChatResponse } from '../../types/response';
 import { IActionWithState } from '../../types/actionWithState';
 import { IActionState } from '../../types/actionState';
+import { ChatInfo } from '../chatInfo';
 
 export class UnpinResponse implements IChatResponse {
-    kind = BotResponseTypes.unpin;
+    readonly kind = BotResponseTypes.unpin;
 
-    messageId: number;
-    chatId: number;
-    traceId: number | string;
-    action: IActionWithState<IActionState>;
+    readonly messageId: number;
+    readonly chatInfo: ChatInfo;
+    readonly traceId: number | string;
+    readonly action: IActionWithState<IActionState>;
 
     constructor(
         messageId: number,
-        chatId: number,
+        chatInfo: ChatInfo,
         traceId: number | string,
         action: IActionWithState<IActionState>
     ) {
         this.messageId = messageId;
-        this.chatId = chatId;
+        this.chatInfo = chatInfo;
         this.traceId = traceId;
         this.action = action;
     }

package/{entities → dtos}/responses/videoMessage.ts

@@ -3,28 +3,29 @@ import { BotResponseTypes, IReplyMessage } from '../../types/response';
 import { MessageSendingOptions } from '../../types/messageSendingOptions';
 import { IActionWithState } from '../../types/actionWithState';
 import { IActionState } from '../../types/actionState';
+import { ChatInfo } from '../chatInfo';
 
 export class VideoMessage implements IReplyMessage<InputFile> {
-    kind = BotResponseTypes.video;
+    readonly kind = BotResponseTypes.video;
 
-    content: InputFile;
-    chatId: number;
-    replyId: number | undefined;
-    traceId: string | number;
-    disableWebPreview = false;
-    shouldPin: boolean;
-    action: IActionWithState<IActionState>;
+    readonly content: InputFile;
+    readonly chatInfo: ChatInfo;
+    readonly replyId: number | undefined;
+    readonly traceId: string | number;
+    readonly disableWebPreview = false;
+    readonly shouldPin: boolean;
+    readonly action: IActionWithState<IActionState>;
 
     constructor(
         video: InputFile,
-        chatId: number,
+        chatInfo: ChatInfo,
         replyId: number | undefined,
         traceId: number | string,
         action: IActionWithState<IActionState>,
         options?: MessageSendingOptions
     ) {
         this.content = video;
-        this.chatId = chatId;
+        this.chatInfo = chatInfo;
         this.replyId = replyId;
         this.traceId = traceId;
         this.shouldPin = options?.pin ?? false;

package/entities/actions/commandAction.ts

@@ -6,25 +6,25 @@ import { secondsToMilliseconds } from '../../helpers/timeConvertions';
 import { toArray } from '../../helpers/toArray';
 import { IActionState } from '../../types/actionState';
 import { IActionWithState, ActionKey } from '../../types/actionWithState';
-import { CommandTriggerCheckResult } from '../commandTriggerCheckResult';
+import { CommandTriggerCheckResult } from '../../dtos/commandTriggerCheckResult';
 import { MessageContext } from '../context/messageContext';
 import { Logger } from '../../services/logger';
-import { ActionExecutionResult } from '../actionExecutionResult';
+import { ActionExecutionResult } from '../../dtos/actionExecutionResult';
 import { CommandTrigger } from '../../types/commandTrigger';
 
 export class CommandAction<TActionState extends IActionState>
     implements IActionWithState<TActionState>
 {
-    triggers: CommandTrigger[];
-    handler: CommandHandler<TActionState>;
-    name: string;
-    cooldownInSeconds: Seconds;
-    active: boolean;
-    chatsBlacklist: number[];
-    allowedUsers: number[];
-    condition: CommandCondition<TActionState>;
-    stateConstructor: () => TActionState;
-    key: ActionKey;
+    readonly triggers: CommandTrigger[];
+    readonly handler: CommandHandler<TActionState>;
+    readonly name: string;
+    readonly cooldownInSeconds: Seconds;
+    readonly active: boolean;
+    readonly chatsBlacklist: number[];
+    readonly allowedUsers: number[];
+    readonly condition: CommandCondition<TActionState>;
+    readonly stateConstructor: () => TActionState;
+    readonly key: ActionKey;
 
     constructor(
         trigger: CommandTrigger | CommandTrigger[],
@@ -56,7 +56,8 @@ export class CommandAction<TActionState extends IActionState>
                 `Context for ${this.key} is not initialized or already consumed`
             );
 
-        if (!this.active || this.chatsBlacklist.includes(ctx.chatId)) return [];
+        if (!this.active || this.chatsBlacklist.includes(ctx.chatInfo.id))
+            return [];
 
         const isConditionMet = await this.condition(ctx);
 
@@ -64,7 +65,7 @@ export class CommandAction<TActionState extends IActionState>
 
         const state = await ctx.storage.getActionState<TActionState>(
             this,
-            ctx.chatId
+            ctx.chatInfo.id
         );
 
         const { shouldTrigger, matchResults, skipCooldown } = this.triggers
@@ -79,8 +80,8 @@ export class CommandAction<TActionState extends IActionState>
         Logger.logWithTraceId(
             ctx.botName,
             ctx.traceId,
-            ctx.chatName,
-            ` - Executing [${this.name}] in ${ctx.chatId}`
+            ctx.chatInfo.name,
+            ` - Executing [${this.name}] in ${ctx.chatInfo.id}`
         );
         ctx.matchResults = matchResults;
 
@@ -98,7 +99,7 @@ export class CommandAction<TActionState extends IActionState>
 
         await ctx.storage.saveActionExecutionResult(
             this,
-            ctx.chatId,
+            ctx.chatInfo.id,
             new ActionExecutionResult(state, ctx.startCooldown && shouldTrigger)
         );
 

package/entities/actions/scheduledAction.ts

@@ -7,25 +7,25 @@ import { IActionState } from '../../types/actionState';
 import { IActionWithState, ActionKey } from '../../types/actionWithState';
 import { CachedStateFactory } from '../cachedStateFactory';
 import { ChatContext } from '../context/chatContext';
-import { ActionExecutionResult } from '../actionExecutionResult';
+import { ActionExecutionResult } from '../../dtos/actionExecutionResult';
 import { Logger } from '../../services/logger';
 import { Scheduler } from '../../services/taskScheduler';
 
 export class ScheduledAction<TActionState extends IActionState>
     implements IActionWithState<TActionState>
 {
-    static locks = new Map<string, Semaphore>();
+    static readonly locks = new Map<string, Semaphore>();
 
-    name: string;
-    timeinHours: HoursOfDay;
-    active: boolean;
-    chatsWhitelist: number[];
-    key: ActionKey;
+    readonly name: string;
+    readonly timeinHours: HoursOfDay;
+    readonly active: boolean;
+    readonly chatsWhitelist: number[];
+    readonly key: ActionKey;
 
-    cachedState = new Map<string, unknown>();
-    stateConstructor: () => TActionState;
-    cachedStateFactories: Map<string, CachedStateFactory>;
-    handler: ScheduledHandler<TActionState>;
+    readonly cachedState = new Map<string, unknown>();
+    readonly stateConstructor: () => TActionState;
+    readonly cachedStateFactories: Map<string, CachedStateFactory>;
+    readonly handler: ScheduledHandler<TActionState>;
 
     constructor(
         name: string,
@@ -52,12 +52,12 @@ export class ScheduledAction<TActionState extends IActionState>
                 `Context for ${this.key} is not initialized or already consumed`
             );
 
-        if (!this.active || !this.chatsWhitelist.includes(ctx.chatId))
+        if (!this.active || !this.chatsWhitelist.includes(ctx.chatInfo.id))
             return [];
 
         const state = await ctx.storage.getActionState<TActionState>(
             this,
-            ctx.chatId
+            ctx.chatInfo.id
         );
         const isAllowedToTrigger = this.shouldTrigger(state);
 
@@ -65,8 +65,8 @@ export class ScheduledAction<TActionState extends IActionState>
             Logger.logWithTraceId(
                 ctx.botName,
                 ctx.traceId,
-                ctx.chatName,
-                ` - Executing [${this.name}] in ${ctx.chatId}`
+                ctx.chatInfo.name,
+                ` - Executing [${this.name}] in ${ctx.chatInfo.id}`
             );
 
             await this.handler(
@@ -81,7 +81,7 @@ export class ScheduledAction<TActionState extends IActionState>
             ctx.updateActions.forEach((action) => action(state));
             await ctx.storage.saveActionExecutionResult(
                 this,
-                ctx.chatId,
+                ctx.chatInfo.id,
                 new ActionExecutionResult(state, isAllowedToTrigger)
             );
         }

package/entities/botInstance.ts

@@ -12,19 +12,20 @@ import { CommandAction } from './actions/commandAction';
 import { ScheduledAction } from './actions/scheduledAction';
 import { Logger } from '../services/logger';
 import { Scheduler } from '../services/taskScheduler';
-import { IncomingMessage } from './incomingMessage';
+import { IncomingMessage } from '../dtos/incomingMessage';
 import moment from 'moment';
 import { ChatContext } from './context/chatContext';
 import { MessageContext } from './context/messageContext';
+import { ChatInfo } from '../dtos/chatInfo';
 
 export class BotInstance {
-    name: string;
-    private api: TelegramApiService;
-    private telegraf: Telegraf;
-    private commands: CommandAction<IActionState>[];
-    private scheduled: ScheduledAction<IActionState>[];
-    private chats: Record<string, number>;
-    storage: IStorageClient;
+    readonly name: string;
+    private readonly api: TelegramApiService;
+    private readonly telegraf: Telegraf;
+    private readonly commands: CommandAction<IActionState>[];
+    private readonly scheduled: ScheduledAction<IActionState>[];
+    private readonly chats: Record<string, number>;
+    readonly storage: IStorageClient;
 
     constructor(options: {
         name: string;
@@ -57,8 +58,7 @@ export class BotInstance {
         this.api = new TelegramApiService(
             this.name,
             this.telegraf.telegram,
-            this.storage,
-            this.chats
+            this.storage
         );
 
         this.initializeMessageProcessing(
@@ -132,14 +132,14 @@ export class BotInstance {
                     Logger.logObjectWithTraceId(
                         this.name,
                         msg.traceId,
-                        msg.chatName,
+                        msg.chatInfo.name,
                         ctx.update.message
                     );
                 } else {
                     Logger.logWithTraceId(
                         this.name,
                         msg.traceId,
-                        msg.chatName,
+                        msg.chatInfo.name,
                         `${messageFromName} (${messageFromId}): ${messageContent}`
                     );
                 }
@@ -166,7 +166,13 @@ export class BotInstance {
 
         for (const [chatName, chatId] of Object.entries(this.chats)) {
             for (const scheduledAction of this.scheduled) {
-                this.api.initializeContextForChat(ctx, chatId, scheduledAction);
+                ctx.initializeChatContext(
+                    this.name,
+                    scheduledAction,
+                    new ChatInfo(chatId, chatName),
+                    `Scheduled:${scheduledAction.key}:${chatId}`,
+                    this.storage
+                );
 
                 try {
                     const responses = await scheduledAction.exec(ctx);
@@ -190,7 +196,12 @@ export class BotInstance {
         const ctx = new MessageContext<IActionState>();
 
         for (const commandAction of this.commands) {
-            this.api.initializeContextForMessage(ctx, msg, commandAction);
+            ctx.initializeMessageContext(
+                this.name,
+                commandAction,
+                msg,
+                this.storage
+            );
 
             try {
                 const responses = await commandAction.exec(ctx);
@@ -199,7 +210,7 @@ export class BotInstance {
                 Logger.errorWithTraceId(
                     ctx.botName,
                     ctx.traceId,
-                    ctx.chatName,
+                    ctx.chatInfo.name,
                     error,
                     ctx
                 );

package/entities/cachedStateFactory.ts

@@ -1,8 +1,8 @@
 import { Hours } from '../types/timeValues';
 
 export class CachedStateFactory {
-    getValue: () => Promise<unknown>;
-    invalidationTimeoutInHours: Hours;
+    readonly getValue: () => Promise<unknown>;
+    readonly invalidationTimeoutInHours: Hours;
 
     constructor(
         itemFactory: () => Promise<unknown>,

package/entities/context/chatContext.ts

@@ -1,9 +1,9 @@
 import { resolve } from 'path';
 import { IStorageClient } from '../../types/storage';
-import { ImageMessage } from '../responses/imageMessage';
-import { TextMessage } from '../responses/textMessage';
-import { VideoMessage } from '../responses/videoMessage';
-import { UnpinResponse } from '../responses/unpin';
+import { ImageMessage } from '../../dtos/responses/imageMessage';
+import { TextMessage } from '../../dtos/responses/textMessage';
+import { VideoMessage } from '../../dtos/responses/videoMessage';
+import { UnpinResponse } from '../../dtos/responses/unpin';
 import {
     MessageSendingOptions,
     TextMessageSendingOptions
@@ -12,7 +12,8 @@ import { IActionWithState } from '../../types/actionWithState';
 import { IActionState } from '../../types/actionState';
 import { BotResponse } from '../../types/response';
 import { Milliseconds } from '../../types/timeValues';
-import { DelayResponse } from '../responses/delay';
+import { DelayResponse } from '../../dtos/responses/delay';
+import { ChatInfo } from '../../dtos/chatInfo';
 
 /**
  * Context of action executed in chat.
@@ -24,10 +25,8 @@ export class ChatContext<TActionState extends IActionState> {
     traceId!: number | string;
     /** Name of a bot that executes this action. */
     botName!: string;
-    /** Id of a chat that action is executed in. */
-    chatId!: number;
-    /** Name of a chat that action is executed in. */
-    chatName!: string;
+    /** Chat information. */
+    chatInfo!: ChatInfo;
     /** Storage client instance for this bot. */
     storage!: IStorageClient;
     /** Ordered collection of responses to be processed  */
@@ -40,15 +39,13 @@ export class ChatContext<TActionState extends IActionState> {
     initializeChatContext(
         botName: string,
         action: IActionWithState<TActionState>,
-        chatId: number,
-        chatName: string,
+        chatInfo: ChatInfo,
         traceId: number | string,
         storage: IStorageClient
     ) {
         this.botName = botName;
         this.action = action;
-        this.chatId = chatId;
-        this.chatName = chatName;
+        this.chatInfo = chatInfo;
         this.traceId = traceId;
         this.storage = storage;
 
@@ -77,7 +74,7 @@ export class ChatContext<TActionState extends IActionState> {
         this.responses.push(
             new TextMessage(
                 text,
-                this.chatId,
+                this.chatInfo,
                 undefined,
                 this.traceId,
                 this.action,
@@ -97,7 +94,7 @@ export class ChatContext<TActionState extends IActionState> {
         this.responses.push(
             new ImageMessage(
                 { source: resolve(filePath) },
-                this.chatId,
+                this.chatInfo,
                 undefined,
                 this.traceId,
                 this.action,
@@ -117,7 +114,7 @@ export class ChatContext<TActionState extends IActionState> {
         this.responses.push(
             new VideoMessage(
                 { source: resolve(filePath) },
-                this.chatId,
+                this.chatInfo,
                 undefined,
                 this.traceId,
                 this.action,
@@ -133,7 +130,12 @@ export class ChatContext<TActionState extends IActionState> {
      */
     unpinMessage(messageId: number) {
         this.responses.push(
-            new UnpinResponse(messageId, this.chatId, this.traceId, this.action)
+            new UnpinResponse(
+                messageId,
+                this.chatInfo,
+                this.traceId,
+                this.action
+            )
         );
     }
 
@@ -143,7 +145,7 @@ export class ChatContext<TActionState extends IActionState> {
      */
     delayNextResponse(delay: Milliseconds) {
         this.responses.push(
-            new DelayResponse(delay, this.chatId, this.traceId, this.action)
+            new DelayResponse(delay, this.chatInfo, this.traceId, this.action)
         );
     }
 }