chz-telegram-bot 0.3.10 → 0.3.12

package/entities/context/replyContext.ts

@@ -13,8 +13,6 @@ import {
     MessageTypeValue,
     TelegrafContextMessage
 } from '../../types/messageTypes';
-import { IScheduler } from '../../types/scheduler';
-import { IStorageClient } from '../../types/storage';
 import { ReplyCaptureAction } from '../actions/replyCaptureAction';
 import { resolve } from 'path';
 import { BaseContext } from './baseContext';
@@ -41,10 +39,6 @@ export class ReplyContext<
 
     isInitialized = false;
 
-    constructor(storage: IStorageClient, scheduler: IScheduler) {
-        super(storage, scheduler);
-    }
-
     private getQuotePart(quote: boolean | string) {
         return typeof quote == 'boolean'
             ? this.matchResults.length != 0
@@ -136,7 +130,9 @@ export class ReplyContext<
                 text: string,
                 quote?: string,
                 options?: TextMessageSendingOptions
-            ) => this.replyWithText(text, quote ?? true, options),
+            ) => {
+                this.replyWithText(text, quote ?? 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.
@@ -147,7 +143,9 @@ export class ReplyContext<
                 name: string,
                 quote?: string,
                 options?: MessageSendingOptions
-            ) => this.replyWithImage(name, quote ?? true, options),
+            ) => {
+                this.replyWithImage(name, quote ?? true, options);
+            },
 
             /**
              * Reply with video/gif message to message that triggered this action after action execution is finished.
@@ -159,7 +157,9 @@ export class ReplyContext<
                 name: string,
                 quote?: string,
                 options?: MessageSendingOptions
-            ) => this.replyWithVideo(name, quote ?? true, options)
+            ) => {
+                this.replyWithVideo(name, quote ?? true, options);
+            }
         },
 
         /**
@@ -168,16 +168,18 @@ export class ReplyContext<
          * @param text Message contents.
          * @param options Message sending option.
          */
-        withText: (text: string, options?: TextMessageSendingOptions) =>
-            this.replyWithText(text, false, options),
+        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),
+        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.
@@ -185,8 +187,9 @@ export class ReplyContext<
          * @param text Message contents.
          * @param options Message sending option.
          */
-        withVideo: (name: string, options?: MessageSendingOptions) =>
-            this.replyWithVideo(name, false, options),
+        withVideo: (name: string, options?: MessageSendingOptions) => {
+            this.replyWithVideo(name, false, options);
+        },
 
         /**
          * React to the message that triggered this action after action execution is finished.

package/eslint.config.js

@@ -3,8 +3,14 @@ import tseslint from 'typescript-eslint';
 
 export default tseslint.config(
     eslint.configs.recommended,
-    ...tseslint.configs.recommended,
+    ...tseslint.configs.strictTypeChecked,
     {
+        languageOptions: {
+            parserOptions: {
+                project: './tsconfig.json',
+                sourceType: 'module'
+            }
+        },
         rules: {
             '@typescript-eslint/no-unused-vars': [
                 'error',
@@ -17,6 +23,25 @@ export default tseslint.config(
                     varsIgnorePattern: '^_',
                     ignoreRestSiblings: true
                 }
+            ],
+            '@typescript-eslint/no-misused-promises': [
+                'error',
+                {
+                    checksVoidReturn: true,
+                    checksConditionals: true
+                }
+            ],
+            '@typescript-eslint/restrict-template-expressions': [
+                'error',
+                {
+                    allowNumber: true
+                }
+            ],
+            '@typescript-eslint/unbound-method': [
+                'error',
+                {
+                    ignoreStatic: true
+                }
             ]
         },
         ignores: ['dist/*']

package/helpers/builders/commandActionBuilder.ts

@@ -23,6 +23,7 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
     stateConstructor: () => TActionState;
     handler: CommandHandler<TActionState> = Noop.call;
     condition: CommandCondition<TActionState> = Noop.true;
+    maxAllowedSimultaniousExecutions: number = 0;
 
     /**
      * Builder for `CommandAction` with state represented by `TActionState`
@@ -86,6 +87,14 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
         return this;
     }
 
+    /** Sets maximum number of simultaniously executing handlers for this command per chat. 0 is treated as unlimited. */
+    ratelimit(maxAllowedSimultaniousExecutions: number) {
+        this.maxAllowedSimultaniousExecutions =
+            maxAllowedSimultaniousExecutions;
+
+        return this;
+    }
+
     /** Sets action cooldown.
      * @param seconds Cooldown in seconds.
      */
@@ -115,6 +124,7 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
             this.cooldownSeconds,
             this.blacklist,
             this.allowedUsers,
+            this.maxAllowedSimultaniousExecutions,
             this.condition,
             this.stateConstructor,
             this.readmeFactory != null ? this.readmeFactory : (_) => ''

package/helpers/mapUtils.ts

@@ -0,0 +1,15 @@
+export function getOrSetIfNotExists<K, V>(map: Map<K, V>, key: K, fallback: V) {
+    const existingValue = map.get(key);
+    if (existingValue) return existingValue;
+
+    map.set(key, fallback);
+
+    return fallback;
+}
+
+export function getOrThrow<K, V>(map: Map<K, V>, key: K, error: string) {
+    const existingValue = map.get(key);
+    if (existingValue) return existingValue;
+
+    throw new Error(error);
+}

package/helpers/noop.ts

@@ -1,16 +1,16 @@
 import { BotResponse } from '../types/response';
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export class Noop {
     static NoResponse: BotResponse[] = [];
-    static true<T1>(arg1: T1) {
+    static true(arg1: unknown) {
         return true;
     }
-    static false<T1>(arg1: T1) {
+    static false(arg1: unknown) {
         return false;
     }
 
-    static async call<T1>(arg1: T1): Promise<void>;
-    static async call<T1, T2>(arg1: T1, arg2: T2): Promise<void>;
+    static async call(arg1: unknown): Promise<void>;
     static async call(arg1: unknown, arg2?: unknown) {}
 }

package/helpers/traceFactory.ts

@@ -1,7 +1,7 @@
 import { TraceId } from '../types/trace';
 
-export function createTrace<T extends object>(
-    traceOwner: T | string,
+export function createTrace(
+    traceOwner: object | string,
     botName: string,
     traceName: string
 ) {

package/package.json

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

package/services/actionProcessingService.ts

@@ -75,13 +75,14 @@ export class ActionProcessingService {
             this.telegraf.telegram,
             this.storage,
             this.logger,
-            (capture, id, chatInfo, traceId) =>
+            (capture, id, chatInfo, traceId) => {
                 this.commandProcessor.captureRegistrationCallback(
                     capture,
                     id,
                     chatInfo,
                     traceId
-                )
+                );
+            }
         );
 
         const botInfo = await this.telegraf.telegram.getMe();
@@ -116,9 +117,12 @@ export class ActionProcessingService {
             scheduledPeriod ?? hoursToSeconds(1 as Hours)
         );
 
-        this.storage.saveMetadata([...actions.scheduled, ...commandActions]);
+        void this.storage.saveMetadata([
+            ...actions.scheduled,
+            ...commandActions
+        ]);
 
-        this.telegraf.launch();
+        void this.telegraf.launch();
     }
 
     stop(code: string) {

package/services/actionProcessors/baseProcessor.ts

@@ -1,4 +1,3 @@
-import { Telegraf } from 'telegraf';
 import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';
 import { IStorageClient } from '../../types/storage';
@@ -14,7 +13,6 @@ export abstract class BaseActionProcessor {
     protected readonly botName: string;
 
     protected api!: TelegramApiService;
-    protected telegraf!: Telegraf;
 
     constructor(
         botName: string,
@@ -29,16 +27,15 @@ export abstract class BaseActionProcessor {
         this.botName = botName;
     }
 
-    private defaultErrorHandler<
-        TAction extends IAction,
-        TActionContext extends BaseContext<TAction>
-    >(error: Error, ctx: TActionContext) {
+    private defaultErrorHandler<TAction extends IAction>(
+        error: Error,
+        ctx: BaseContext<TAction>
+    ) {
         ctx.logger.errorWithTraceId(error, ctx);
     }
 
-    initializeDependencies(api: TelegramApiService, telegraf: Telegraf) {
+    initializeDependencies(api: TelegramApiService) {
         this.api = api;
-        this.telegraf = telegraf;
     }
 
     async executeAction<

package/services/actionProcessors/commandActionProcessor.ts

@@ -5,9 +5,6 @@ import { ReplyCaptureAction } from '../../entities/actions/replyCaptureAction';
 import { MessageContext } from '../../entities/context/messageContext';
 import { ReplyContext } from '../../entities/context/replyContext';
 import { IActionState } from '../../types/actionState';
-import { ILogger } from '../../types/logger';
-import { IScheduler } from '../../types/scheduler';
-import { IStorageClient } from '../../types/storage';
 import { TelegramApiService } from '../telegramApi';
 import { IReplyCapture } from '../../types/capture';
 import { TraceId } from '../../types/trace';
@@ -29,22 +26,13 @@ export class CommandActionProcessor extends BaseActionProcessor {
         ])
     );
 
-    constructor(
-        botName: string,
-        storage: IStorageClient,
-        scheduler: IScheduler,
-        logger: ILogger
-    ) {
-        super(botName, storage, scheduler, logger);
-    }
-
     initialize(
         api: TelegramApiService,
         telegraf: Telegraf,
         commands: CommandAction<IActionState>[],
         verboseLoggingForIncomingMessage: boolean
     ) {
-        this.initializeDependencies(api, telegraf);
+        this.initializeDependencies(api);
 
         for (const msgType of Object.values(MessageType)) {
             if (msgType == MessageType.Text) {
@@ -72,7 +60,7 @@ export class CommandActionProcessor extends BaseActionProcessor {
         }
 
         if (commands.length > 0) {
-            this.telegraf.on('message', async (ctx) => {
+            telegraf.on('message', (ctx) => {
                 const msg = new IncomingMessage(
                     ctx.update.message,
                     this.botName
@@ -94,7 +82,7 @@ export class CommandActionProcessor extends BaseActionProcessor {
                     );
                 }
 
-                await this.processMessage(msg);
+                void this.processMessage(msg);
             });
         }
     }
@@ -174,7 +162,7 @@ export class CommandActionProcessor extends BaseActionProcessor {
     ) {
         ctx.replyMessageId = message.replyToMessageId;
         ctx.messageId = message.messageId;
-        ctx.messageText = message.text ?? '';
+        ctx.messageText = message.text;
         ctx.messageType = message.type;
         ctx.fromUserId = message.from?.id;
         ctx.fromUserName =
@@ -202,7 +190,7 @@ export class CommandActionProcessor extends BaseActionProcessor {
         message: IncomingMessage
     ) {
         ctx.messageId = message.messageId;
-        ctx.messageText = message.text ?? '';
+        ctx.messageText = message.text;
         ctx.messageType = message.type;
         ctx.fromUserId = message.from?.id;
         ctx.fromUserName =

package/services/actionProcessors/inlineQueryActionProcessor.ts

@@ -3,9 +3,6 @@ import { IncomingInlineQuery } from '../../dtos/incomingQuery';
 import { InlineQueryAction } from '../../entities/actions/inlineQueryAction';
 import { InlineQueryContext } from '../../entities/context/inlineQueryContext';
 import { createTrace } from '../../helpers/traceFactory';
-import { ILogger } from '../../types/logger';
-import { IScheduler } from '../../types/scheduler';
-import { IStorageClient } from '../../types/storage';
 import { Milliseconds } from '../../types/timeValues';
 import { TraceId } from '../../types/trace';
 import { TelegramApiService } from '../telegramApi';
@@ -14,22 +11,13 @@ import { BaseActionProcessor } from './baseProcessor';
 export class InlineQueryActionProcessor extends BaseActionProcessor {
     private inlineQueries!: InlineQueryAction[];
 
-    constructor(
-        botName: string,
-        storage: IStorageClient,
-        scheduler: IScheduler,
-        logger: ILogger
-    ) {
-        super(botName, storage, scheduler, logger);
-    }
-
     initialize(
         api: TelegramApiService,
         telegraf: Telegraf,
         inlineQueries: InlineQueryAction[],
         period: Milliseconds
     ) {
-        this.initializeDependencies(api, telegraf);
+        this.initializeDependencies(api);
         this.inlineQueries = inlineQueries;
 
         let pendingInlineQueries: IncomingInlineQuery[] = [];
@@ -37,7 +25,7 @@ export class InlineQueryActionProcessor extends BaseActionProcessor {
         const queriesInProcessing = new Map<number, IncomingInlineQuery>();
 
         if (this.inlineQueries.length > 0) {
-            this.telegraf.on('inline_query', async (ctx) => {
+            telegraf.on('inline_query', (ctx) => {
                 const query = new IncomingInlineQuery(
                     ctx.inlineQuery.id,
                     ctx.inlineQuery.query,
@@ -52,7 +40,9 @@ export class InlineQueryActionProcessor extends BaseActionProcessor {
                 );
 
                 logger.logWithTraceId(
-                    `${ctx.inlineQuery.from.username} (${ctx.inlineQuery.from.id}): Query for ${ctx.inlineQuery.query}`
+                    `${ctx.inlineQuery.from.username ?? 'Unknown'} (${
+                        ctx.inlineQuery.from.id
+                    }): Query for ${ctx.inlineQuery.query}`
                 );
 
                 const queryBeingProcessed = queriesInProcessing.get(

package/services/actionProcessors/scheduledActionProcessor.ts

@@ -34,7 +34,7 @@ export class ScheduledActionProcessor extends BaseActionProcessor {
         scheduled: ScheduledAction<IActionState>[],
         period: Seconds
     ) {
-        this.initializeDependencies(api, null!);
+        this.initializeDependencies(api);
         this.scheduled = scheduled;
 
         if (this.scheduled.length > 0) {
@@ -63,11 +63,11 @@ export class ScheduledActionProcessor extends BaseActionProcessor {
 
             this.scheduler.createOnetimeTask(
                 'ScheduledProcessing_OneTime',
-                async () => {
+                () => {
                     this.scheduler.createTask(
                         'ScheduledProcessing',
-                        async () => {
-                            await this.runScheduled();
+                        () => {
+                            void this.runScheduled();
                         },
                         secondsToMilliseconds(period),
                         true,

package/services/jsonFileStorage.ts

@@ -4,6 +4,7 @@ import { Sema as Semaphore } from 'async-sema';
 import { IStorageClient } from '../types/storage';
 import { IActionState } from '../types/actionState';
 import { IActionWithState, ActionKey } from '../types/action';
+import { getOrSetIfNotExists } from '../helpers/mapUtils';
 
 function buildPath(storagePath: string, botName: string, actionKey: string) {
     return `${storagePath}/${botName}/${actionKey.replaceAll(':', '/')}.json`;
@@ -40,10 +41,21 @@ export class JsonFileStorage implements IStorageClient {
         }
     }
 
-    private async lock<TType>(key: ActionKey, action: () => Promise<TType>) {
-        if (!this.locks.has(key)) this.locks.set(key, new Semaphore(1));
+    private backfillEmptyActionStates<TActionState extends IActionState>(
+        action: IActionWithState<TActionState>,
+        data: Record<number, TActionState | undefined>
+    ): data is Record<number, TActionState> {
+        for (const [stringKey, value] of Object.entries(data)) {
+            if (value) continue;
+
+            data[parseInt(stringKey)] = action.stateConstructor();
+        }
 
-        const lock = this.locks.get(key)!;
+        return true;
+    }
+
+    private async lock<TType>(key: ActionKey, action: () => Promise<TType>) {
+        const lock = getOrSetIfNotExists(this.locks, key, new Semaphore(1));
 
         await lock.acquire();
 
@@ -61,12 +73,11 @@ export class JsonFileStorage implements IStorageClient {
     private async loadFromFile<TActionState extends IActionState>(
         key: ActionKey
     ) {
-        if (!this.filePaths.has(key))
-            this.filePaths.set(
-                key,
-                buildPath(this.storagePath, this.botName, key)
-            );
-        const targetPath = this.filePaths.get(key)!;
+        const targetPath = getOrSetIfNotExists(
+            this.filePaths,
+            key,
+            buildPath(this.storagePath, this.botName, key)
+        );
 
         const fileContent = await readFile(targetPath, {
             encoding: 'utf-8',
@@ -74,12 +85,18 @@ export class JsonFileStorage implements IStorageClient {
         });
 
         if (fileContent) {
-            const data = JSON.parse(fileContent);
+            const data = JSON.parse(fileContent) as Record<
+                number,
+                TActionState
+            >;
 
             this.cache.set(key, data);
         }
 
-        return (this.cache.get(key) ?? {}) as Record<number, TActionState>;
+        return (this.cache.get(key) ?? {}) as Record<
+            number,
+            TActionState | undefined
+        >;
     }
 
     private async updateCacheAndSaveToFile<TActionState extends IActionState>(
@@ -88,12 +105,11 @@ export class JsonFileStorage implements IStorageClient {
     ) {
         this.cache.set(key, data);
 
-        if (!this.filePaths.has(key))
-            this.filePaths.set(
-                key,
-                buildPath(this.storagePath, this.botName, key)
-            );
-        const targetPath = this.filePaths.get(key)!;
+        const targetPath = getOrSetIfNotExists(
+            this.filePaths,
+            key,
+            buildPath(this.storagePath, this.botName, key)
+        );
 
         await writeFile(targetPath, JSON.stringify(data), { flag: 'w+' });
     }
@@ -133,14 +149,15 @@ export class JsonFileStorage implements IStorageClient {
         chatId: number,
         state: TActionState
     ) {
-        return await this.lock(action.key, async () => {
+        await this.lock(action.key, async () => {
             const data =
                 this.tryGetFromCache<TActionState>(action.key) ??
                 (await this.loadFromFile<TActionState>(action.key));
 
             data[chatId] = state;
 
-            await this.updateCacheAndSaveToFile(data, action.key);
+            if (this.backfillEmptyActionStates(action, data))
+                await this.updateCacheAndSaveToFile(data, action.key);
         });
     }
 
@@ -153,7 +170,7 @@ export class JsonFileStorage implements IStorageClient {
     async updateStateFor<TActionState extends IActionState>(
         action: IActionWithState<TActionState>,
         chatId: number,
-        update: (state: TActionState) => Promise<void>
+        update: (state: TActionState) => Promise<void> | void
     ) {
         await this.lock(action.key, async () => {
             const data =
@@ -167,7 +184,8 @@ export class JsonFileStorage implements IStorageClient {
 
             await update(state);
 
-            await this.updateCacheAndSaveToFile(data, action.key);
+            if (this.backfillEmptyActionStates(action, data))
+                await this.updateCacheAndSaveToFile(data, action.key);
         });
     }
 }

package/services/jsonLogger.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ILogger, IScopedLogger } from '../types/logger';
 import { TraceId } from '../types/trace';
@@ -13,18 +14,21 @@ export class JsonLogger implements ILogger {
 
     createScope(botName: string, traceId: TraceId, chatName: string) {
         return {
-            logObjectWithTraceId: (data: any) =>
-                this.logObjectWithTraceId(botName, traceId, chatName, data),
-            logWithTraceId: (text: string) =>
-                this.logWithTraceId(botName, traceId, chatName, text),
-            errorWithTraceId: <TData>(errorObj: unknown, extraData?: TData) =>
+            logObjectWithTraceId: (data: any) => {
+                this.logObjectWithTraceId(botName, traceId, chatName, data);
+            },
+            logWithTraceId: (text: string) => {
+                this.logWithTraceId(botName, traceId, chatName, text);
+            },
+            errorWithTraceId: (errorObj: unknown, extraData?: unknown) => {
                 this.errorWithTraceId(
                     botName,
                     traceId,
                     chatName,
                     errorObj,
                     extraData
-                )
+                );
+            }
         } as IScopedLogger;
     }
 
@@ -51,12 +55,12 @@ export class JsonLogger implements ILogger {
         );
     }
 
-    errorWithTraceId<TData>(
+    errorWithTraceId(
         botName: string,
         traceId: TraceId,
         chatName: string,
         errorObj: unknown,
-        extraData?: TData
+        extraData?: unknown
     ) {
         console.error(
             `{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","error":${this.serializeError(

package/services/nodeTimeoutScheduler.ts

@@ -20,7 +20,7 @@ export class NodeTimeoutScheduler implements IScheduler {
 
     createTask(
         name: string,
-        action: () => void,
+        action: () => unknown,
         interval: Milliseconds,
         executeRightAway: boolean,
         ownerName: string
@@ -36,7 +36,7 @@ export class NodeTimeoutScheduler implements IScheduler {
             ownerName,
             createTrace(this, ownerName, name),
             'System',
-            `Created task [${taskId}]${name}, that will run every ${interval}ms.`
+            `Created task ${name}, that will run every ${interval}ms.`
         );
 
         this.activeTasks.push(task);
@@ -44,7 +44,7 @@ export class NodeTimeoutScheduler implements IScheduler {
 
     createOnetimeTask(
         name: string,
-        action: () => void,
+        action: () => unknown,
         delay: Milliseconds,
         ownerName: string
     ) {
@@ -53,17 +53,17 @@ export class NodeTimeoutScheduler implements IScheduler {
                 ownerName,
                 createTrace(this, ownerName, name),
                 'System',
-                `Executing delayed oneshot [${taskId}]${name}`
+                `Executing delayed oneshot ${name}`
             );
             action();
         };
-        const taskId = setTimeout(actionWrapper, delay);
+        setTimeout(actionWrapper, delay);
 
         this.logger.logWithTraceId(
             ownerName,
             createTrace(this, ownerName, name),
             'System',
-            `Created oneshot task [${taskId}]${name}, that will run in ${delay}ms.`
+            `Created oneshot task ${name}, that will run in ${delay}ms.`
         );
     }
 }