chz-telegram-bot 0.0.50 → 0.0.52

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,24 @@ 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 { CommandTrigger } from '../../types/commandTrigger';
+import { Noop } from '../../helpers/noop';
 
 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,31 +55,28 @@ 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 [];
-
-        const isConditionMet = await this.condition(ctx);
-
-        if (!isConditionMet) return [];
+        if (!this.active || this.chatsBlacklist.includes(ctx.chatInfo.id))
+            return Noop.NoResponse;
 
         const state = await ctx.storage.getActionState<TActionState>(
             this,
-            ctx.chatId
+            ctx.chatInfo.id
         );
 
-        const { shouldTrigger, matchResults, skipCooldown } = this.triggers
-            .map((x) => this.checkTrigger(ctx, x, state))
+        const { shouldExecute, matchResults, skipCooldown } = this.triggers
+            .map((x) => this.checkIfShouldBeExecuted(ctx, x, state))
             .reduce(
                 (acc, curr) => acc.mergeWith(curr),
                 CommandTriggerCheckResult.DoNotTrigger
             );
 
-        if (!shouldTrigger) return [];
+        if (!shouldExecute) return Noop.NoResponse;
 
-        Logger.logWithTraceId(
+        ctx.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;
 
@@ -94,27 +90,20 @@ export class CommandAction<TActionState extends IActionState>
             state.lastExecutedDate = moment().valueOf();
         }
 
-        ctx.updateActions.forEach((action) => action(state));
-
         await ctx.storage.saveActionExecutionResult(
             this,
-            ctx.chatId,
-            new ActionExecutionResult(state, ctx.startCooldown && shouldTrigger)
+            ctx.chatInfo.id,
+            state
         );
 
-        ctx.isInitialized = false;
-
         return ctx.responses;
     }
 
-    private checkTrigger(
+    private checkIfShouldBeExecuted(
         ctx: MessageContext<TActionState>,
         trigger: CommandTrigger,
         state: IActionState
     ) {
-        let shouldTrigger = false;
-        const matchResults: RegExpExecArray[] = [];
-
         if (!ctx.fromUserId)
             return CommandTriggerCheckResult.DontTriggerAndSkipCooldown;
 
@@ -134,28 +123,11 @@ export class CommandAction<TActionState extends IActionState>
 
         if (onCooldown) return CommandTriggerCheckResult.DoNotTrigger;
 
-        if (trigger == ctx.messageType) {
-            shouldTrigger = true;
-        } else if (typeof trigger == 'string') {
-            shouldTrigger = ctx.messageText.toLowerCase() == trigger;
-        } else {
-            trigger.lastIndex = 0;
-
-            const execResult = trigger.exec(ctx.messageText);
-            if (execResult != null) {
-                matchResults.push(execResult);
-
-                if (trigger.global) {
-                    while (true) {
-                        const nextResult = trigger.exec(ctx.messageText);
-                        if (nextResult == null) break;
-                        matchResults.push(nextResult);
-                    }
-                }
-            }
+        const isCustomConditionMet = this.condition(ctx);
+        if (!isCustomConditionMet)
+            return CommandTriggerCheckResult.DontTriggerAndSkipCooldown;
 
-            shouldTrigger = matchResults.length > 0;
-        }
+        const { shouldTrigger, matchResults } = this.checkTrigger(ctx, trigger);
 
         return new CommandTriggerCheckResult(
             shouldTrigger,
@@ -163,4 +135,40 @@ export class CommandAction<TActionState extends IActionState>
             false
         );
     }
+
+    private checkTrigger(
+        ctx: MessageContext<TActionState>,
+        trigger: CommandTrigger
+    ) {
+        if (trigger == ctx.messageType)
+            return { shouldTrigger: true, matchResults: [] };
+
+        if (typeof trigger == 'string')
+            return {
+                shouldTrigger: ctx.messageText.toLowerCase() == trigger,
+                matchResults: []
+            };
+
+        const matchResults: RegExpExecArray[] = [];
+
+        trigger.lastIndex = 0;
+
+        const execResult = trigger.exec(ctx.messageText);
+        if (execResult != null) {
+            matchResults.push(execResult);
+
+            if (trigger.global) {
+                while (true) {
+                    const nextResult = trigger.exec(ctx.messageText);
+                    if (nextResult == null) break;
+                    matchResults.push(nextResult);
+                }
+            }
+        }
+
+        return {
+            shouldTrigger: matchResults.length > 0,
+            matchResults
+        };
+    }
 }

package/entities/actions/scheduledAction.ts

@@ -7,25 +7,24 @@ 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 { Logger } from '../../services/logger';
-import { Scheduler } from '../../services/taskScheduler';
+import { Noop } from '../../helpers/noop';
+import { IScheduler } from '../../types/scheduler';
 
 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,48 +51,46 @@ export class ScheduledAction<TActionState extends IActionState>
                 `Context for ${this.key} is not initialized or already consumed`
             );
 
-        if (!this.active || !this.chatsWhitelist.includes(ctx.chatId))
-            return [];
+        if (!this.active || !this.chatsWhitelist.includes(ctx.chatInfo.id))
+            return Noop.NoResponse;
 
         const state = await ctx.storage.getActionState<TActionState>(
             this,
-            ctx.chatId
+            ctx.chatInfo.id
         );
-        const isAllowedToTrigger = this.shouldTrigger(state);
-
-        if (isAllowedToTrigger) {
-            Logger.logWithTraceId(
-                ctx.botName,
-                ctx.traceId,
-                ctx.chatName,
-                ` - Executing [${this.name}] in ${ctx.chatId}`
-            );
 
-            await this.handler(
-                ctx,
-                <TResult>(key: string) =>
-                    this.getCachedValue<TResult>(key, ctx.botName),
-                state
-            );
+        const isAllowedToTrigger = this.checkIfShouldBeExecuted(state);
+        if (!isAllowedToTrigger) return Noop.NoResponse;
 
-            state.lastExecutedDate = moment().valueOf();
+        ctx.logger.logWithTraceId(
+            ctx.botName,
+            ctx.traceId,
+            ctx.chatInfo.name,
+            ` - Executing [${this.name}] in ${ctx.chatInfo.id}`
+        );
 
-            ctx.updateActions.forEach((action) => action(state));
-            await ctx.storage.saveActionExecutionResult(
-                this,
-                ctx.chatId,
-                new ActionExecutionResult(state, isAllowedToTrigger)
-            );
-        }
+        await this.handler(
+            ctx,
+            <TResult>(key: string) =>
+                this.getCachedValue<TResult>(key, ctx.botName, ctx.scheduler),
+            state
+        );
+
+        state.lastExecutedDate = moment().valueOf();
 
-        ctx.isInitialized = false;
+        await ctx.storage.saveActionExecutionResult(
+            this,
+            ctx.chatInfo.id,
+            state
+        );
 
         return ctx.responses;
     }
 
     private async getCachedValue<TResult>(
         key: string,
-        botName: string
+        botName: string,
+        scheduler: IScheduler
     ): Promise<TResult> {
         if (!this.cachedStateFactories.has(key)) {
             throw new Error(
@@ -122,7 +119,7 @@ export class ScheduledAction<TActionState extends IActionState>
 
             this.cachedState.set(key, value);
 
-            Scheduler.createOnetimeTask(
+            scheduler.createOnetimeTask(
                 `Drop cached value [${this.name} : ${key}]`,
                 () => this.cachedState.delete(key),
                 hoursToMilliseconds(
@@ -137,7 +134,7 @@ export class ScheduledAction<TActionState extends IActionState>
         }
     }
 
-    private shouldTrigger(state: IActionState): boolean {
+    private checkIfShouldBeExecuted(state: IActionState): boolean {
         const startOfToday = moment().startOf('day').valueOf();
         const lastExecutedDate = moment(state.lastExecutedDate);
         const currentTime = moment();