chz-telegram-bot 0.0.25 → 0.0.27

package/entities/responses/reaction.ts

@@ -1,5 +1,6 @@
 import { TelegramEmoji } from 'telegraf/types';
 import { BotResponseTypes, IChatResponse } from '../../types/response';
+import { IActionWithState } from '../../types/actionWithState';
 
 export class Reaction implements IChatResponse {
     kind = BotResponseTypes.react;
@@ -8,19 +9,19 @@ export class Reaction implements IChatResponse {
     messageId: number;
     traceId: number | string;
     emoji: TelegramEmoji;
-    sourceActionKey: string;
+    action: IActionWithState;
 
     constructor(
         traceId: number | string,
         chatId: number,
         messageId: number,
         emoji: TelegramEmoji,
-        sourceActionKey: string
+        action: IActionWithState
     ) {
         this.chatId = chatId;
         this.messageId = messageId;
         this.emoji = emoji;
         this.traceId = traceId;
-        this.sourceActionKey = sourceActionKey;
+        this.action = action;
     }
 }

package/entities/responses/textMessage.ts

@@ -1,5 +1,6 @@
 import { TextMessageSendingOptions } from '../../types/messageSendingOptions';
 import { BotResponseTypes, IReplyMessage } from '../../types/response';
+import { IActionWithState } from '../../types/actionWithState';
 
 export class TextMessage implements IReplyMessage<string> {
     kind = BotResponseTypes.text;
@@ -10,14 +11,14 @@ export class TextMessage implements IReplyMessage<string> {
     traceId: string | number;
     disableWebPreview: boolean;
     shouldPin: boolean;
-    sourceActionKey: string;
+    action: IActionWithState;
 
     constructor(
         text: string,
         chatId: number,
         replyId: number | undefined,
         traceId: string | number,
-        sourceActionKey: string,
+        action: IActionWithState,
         options?: TextMessageSendingOptions
     ) {
         this.content = text;
@@ -26,6 +27,6 @@ export class TextMessage implements IReplyMessage<string> {
         this.traceId = traceId;
         this.disableWebPreview = options?.disableWebPreview ?? false;
         this.shouldPin = options?.pin ?? false;
-        this.sourceActionKey = sourceActionKey;
+        this.action = action;
     }
 }

package/entities/responses/unpin.ts

@@ -1,4 +1,5 @@
 import { BotResponseTypes, IChatResponse } from '../../types/response';
+import { IActionWithState } from '../../types/actionWithState';
 
 export class UnpinResponse implements IChatResponse {
     kind = BotResponseTypes.unpin;
@@ -6,17 +7,17 @@ export class UnpinResponse implements IChatResponse {
     messageId: number;
     chatId: number;
     traceId: number | string;
-    sourceActionKey: string;
+    action: IActionWithState;
 
     constructor(
         messageId: number,
         chatId: number,
         traceId: number | string,
-        sourceActionKey: string
+        action: IActionWithState
     ) {
         this.messageId = messageId;
         this.chatId = chatId;
         this.traceId = traceId;
-        this.sourceActionKey = sourceActionKey;
+        this.action = action;
     }
 }

package/entities/responses/videoMessage.ts

@@ -1,6 +1,7 @@
 import { InputFile } from 'telegraf/types';
 import { BotResponseTypes, IReplyMessage } from '../../types/response';
 import { MessageSendingOptions } from '../../types/messageSendingOptions';
+import { IActionWithState } from '../../types/actionWithState';
 
 export class VideoMessage implements IReplyMessage<InputFile> {
     kind = BotResponseTypes.video;
@@ -11,14 +12,14 @@ export class VideoMessage implements IReplyMessage<InputFile> {
     traceId: string | number;
     disableWebPreview = false;
     shouldPin: boolean;
-    sourceActionKey: string;
+    action: IActionWithState;
 
     constructor(
         video: InputFile,
         chatId: number,
         replyId: number | undefined,
         traceId: number | string,
-        sourceActionKey: string,
+        action: IActionWithState,
         options?: MessageSendingOptions
     ) {
         this.content = video;
@@ -26,6 +27,6 @@ export class VideoMessage implements IReplyMessage<InputFile> {
         this.replyId = replyId;
         this.traceId = traceId;
         this.shouldPin = options?.pin ?? false;
-        this.sourceActionKey = sourceActionKey;
+        this.action = action;
     }
 }

package/helpers/builders/commandActionBuilder.ts

@@ -12,7 +12,7 @@ import { Noop } from '../noop';
  */
 export class CommandActionBuilderWithState<TActionState extends IActionState> {
     name: string;
-    trigger: string | RegExp | Array<string> | Array<RegExp> = [];
+    trigger: string | RegExp | string[] | RegExp[] = [];
 
     active = true;
     cooldownSeconds: Seconds = 0 as Seconds;
@@ -38,7 +38,7 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
      *
      * If `RegExp` or `RegExp[]` is provided, will be triggered on successful match.
      */
-    on(trigger: string | RegExp | Array<string> | Array<RegExp>) {
+    on(trigger: string | RegExp | string[] | RegExp[]) {
         this.trigger = trigger;
 
         return this;
@@ -47,7 +47,7 @@ export class CommandActionBuilderWithState<TActionState extends IActionState> {
     /** Defines id (or ids) of users that are allowed to trigger this action.
      * @param id User id or ids
      */
-    from(id: number | Array<number>) {
+    from(id: number | number[]) {
         this.allowedUsers = toArray(id);
 
         return this;

package/package.json

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

package/services/jsonFileStorage.ts

@@ -6,15 +6,15 @@ import { IStorageClient } from '../types/storage';
 import { ActionStateBase } from '../entities/states/actionStateBase';
 import { ActionExecutionResult } from '../entities/actionExecutionResult';
 import { IActionState } from '../types/actionState';
-import { IActionWithState } from '../types/actionWithState';
+import { IActionWithState, ActionKey } from '../types/actionWithState';
 
 export class JsonFileStorage implements IStorageClient {
-    semaphore = new Semaphore(1);
+    private locks = new Map<ActionKey, Semaphore>();
     private cache: Map<string, Record<number, IActionState>>;
     private storagePath: string;
     private botName: string;
 
-    constructor(botName: string, path?: string) {
+    constructor(botName: string, actions: IActionWithState[], path?: string) {
         this.cache = new Map<string, Record<number, IActionState>>();
         this.botName = botName;
         this.storagePath = path ?? 'storage';
@@ -24,19 +24,31 @@ export class JsonFileStorage implements IStorageClient {
                 recursive: true
             });
         }
+
+        for (const action of actions) {
+            this.locks.set(action.key, new Semaphore(1));
+        }
     }
 
-    private async lock<TType>(action: () => Promise<TType>) {
-        await this.semaphore.acquire();
+    private async lock<TType>(key: ActionKey, action: () => Promise<TType>) {
+        const lock = this.locks.get(key);
+
+        if (!lock) {
+            throw new Error(`Lock for action ${key} not found`);
+        }
+
+        await lock.acquire();
 
         try {
             return await action();
         } finally {
-            this.semaphore.release();
+            lock.release();
         }
     }
 
-    private async loadInternal<TActionState extends IActionState>(key: string) {
+    private async loadInternal<TActionState extends IActionState>(
+        key: ActionKey
+    ) {
         if (!this.cache.has(key)) {
             const targetPath = this.buidPathFromKey(key);
             if (!existsSync(targetPath)) {
@@ -55,7 +67,7 @@ export class JsonFileStorage implements IStorageClient {
         return (this.cache.get(key) ?? {}) as Record<number, TActionState>;
     }
 
-    private async save(data: Record<number, ActionStateBase>, key: string) {
+    private async save(data: Record<number, ActionStateBase>, key: ActionKey) {
         this.cache.delete(key);
 
         const targetPath = this.buidPathFromKey(key);
@@ -68,38 +80,38 @@ export class JsonFileStorage implements IStorageClient {
         await writeFile(targetPath, JSON.stringify(data), { flag: 'w+' });
     }
 
-    private buidPathFromKey(key: string) {
+    private buidPathFromKey(key: ActionKey) {
         return `${this.storagePath}/${this.botName}/${key.replaceAll(
             ':',
             '/'
         )}.json`;
     }
 
-    async load<TActionState extends IActionState>(key: string) {
-        return await this.lock(async () => {
+    async load<TActionState extends IActionState>(key: ActionKey) {
+        return await this.lock(key, async () => {
             return this.loadInternal<TActionState>(key);
         });
     }
 
     async saveMetadata(actions: IActionWithState[], botName: string) {
-        return await this.lock(async () => {
-            const targetPath = this.buidPathFromKey(`Metadata-${botName}`);
+        const targetPath = this.buidPathFromKey(
+            `Metadata-${botName}` as ActionKey
+        );
 
-            await writeFile(targetPath, JSON.stringify(actions), {
-                flag: 'w+'
-            });
+        await writeFile(targetPath, JSON.stringify(actions), {
+            flag: 'w+'
         });
     }
 
     async getActionState<TActionState extends IActionState>(
-        entity: IActionWithState,
+        action: IActionWithState,
         chatId: number
     ) {
-        return await this.lock(async () => {
-            const data = await this.loadInternal(entity.key);
+        return await this.lock(action.key, async () => {
+            const data = await this.loadInternal(action.key);
 
             return Object.assign(
-                entity.stateConstructor(),
+                action.stateConstructor(),
                 data[chatId]
             ) as TActionState;
         });
@@ -110,7 +122,7 @@ export class JsonFileStorage implements IStorageClient {
         chatId: number,
         transactionResult: ActionExecutionResult
     ) {
-        await this.lock(async () => {
+        await this.lock(action.key, async () => {
             const data = await this.loadInternal(action.key);
 
             if (transactionResult.shouldUpdate) {
@@ -121,24 +133,26 @@ export class JsonFileStorage implements IStorageClient {
     }
 
     async close(): Promise<void> {
-        await this.semaphore.acquire();
+        for (const lock of this.locks.values()) {
+            await lock.acquire();
+        }
     }
 
     async updateStateFor<TActionState extends IActionState>(
-        sourceActionKey: string,
+        action: IActionWithState,
         chatId: number,
         update: (state: TActionState) => Promise<void>
     ) {
-        await this.lock(async () => {
-            const data = await this.loadInternal(sourceActionKey);
+        await this.lock(action.key, async () => {
+            const data = await this.loadInternal(action.key);
             const state = Object.assign(
-                new ActionStateBase(),
+                action.stateConstructor(),
                 data[chatId]
             ) as TActionState;
 
             await update(state);
 
-            await this.save(data, sourceActionKey);
+            await this.save(data, action.key);
         });
     }
 }

package/services/logger.ts

@@ -14,7 +14,9 @@ class JsonLogger {
         chatName: string,
         text: string
     ) {
-        console.log(JSON.stringify({ botName, traceId, chatName, text }));
+        console.log(
+            `{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","text":"${text}"}`
+        );
     }
 
     errorWithTraceId<TData>(
@@ -25,13 +27,9 @@ class JsonLogger {
         extraData?: TData | undefined
     ) {
         console.error(
-            JSON.stringify({
-                botName,
-                traceId,
-                chatName,
-                error: this.serializeError(errorObj),
-                extraData
-            })
+            `{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","error":${this.serializeError(
+                errorObj
+            )}${extraData ? `,"extraData":${JSON.stringify(extraData)}` : ''}}`
         );
     }
 }

package/services/taskScheduler.ts

@@ -18,7 +18,6 @@ class TaskScheduler {
         executeRightAway: boolean,
         ownerName: string
     ) {
-        executeRightAway = executeRightAway ?? false;
         const taskId = setInterval(action, interval);
         const task = new TaskRecord(name, taskId, interval);
 

package/services/telegramApi.ts

@@ -18,9 +18,11 @@ import { ScheduledAction } from '../entities/actions/scheduledAction';
 import { IActionState } from '../types/actionState';
 import { CommandAction } from '../entities/actions/commandAction';
 
+const TELEGRAM_RATELIMIT_DELAY = 35 as Milliseconds;
+
 export class TelegramApiService {
     isFlushing = false;
-    messageQueue: Array<BotResponse> = [];
+    messageQueue: BotResponse[] = [];
 
     botName: string;
     telegram: Telegram;
@@ -51,7 +53,7 @@ export class TelegramApiService {
 
             try {
                 await this.processResponse(message);
-                await setTimeout(100 as Milliseconds);
+                await setTimeout(TELEGRAM_RATELIMIT_DELAY);
             } catch (error) {
                 Logger.errorWithTraceId(
                     this.botName,
@@ -78,7 +80,7 @@ export class TelegramApiService {
             );
 
             await this.storage.updateStateFor(
-                response.sourceActionKey,
+                response.action,
                 response.chatId,
                 async (state) => {
                     state.pinnedMessages.push(sentMessage.message_id);
@@ -150,7 +152,7 @@ export class TelegramApiService {
                 );
 
                 await this.storage.updateStateFor(
-                    response.sourceActionKey,
+                    response.action,
                     response.chatId,
                     async (state) => {
                         state.pinnedMessages = state.pinnedMessages.filter(
@@ -178,22 +180,11 @@ export class TelegramApiService {
         incomingMessage: IncomingMessage,
         command: CommandAction<TActionState>
     ) {
-        const firstName = incomingMessage.from?.first_name ?? 'Unknown user';
-        const lastName = incomingMessage.from?.last_name
-            ? ` ${incomingMessage.from?.last_name}`
-            : '';
-
         return new MessageContext<TActionState>(
             this.botName,
-            command.key,
+            command,
             this.getInteractions(),
-            incomingMessage.chat.id,
-            incomingMessage.chatName,
-            incomingMessage.message_id,
-            incomingMessage.text,
-            incomingMessage.from?.id,
-            incomingMessage.traceId,
-            firstName + lastName,
+            incomingMessage,
             this.storage
         );
     }
@@ -204,7 +195,7 @@ export class TelegramApiService {
     ) {
         return new ChatContext<TActionState>(
             this.botName,
-            scheduledAction.key,
+            scheduledAction,
             this.getInteractions(),
             chatId,
             this.chats[chatId],

package/types/actionWithState.ts

@@ -1,6 +1,8 @@
 import { IActionState } from './actionState';
 
+export type ActionKey = string & { __brand: 'actionKey' };
+
 export interface IActionWithState {
-    key: string;
+    key: ActionKey;
     stateConstructor: () => IActionState;
 }

package/types/response.ts

@@ -3,6 +3,7 @@ import { Reaction } from '../entities/responses/reaction';
 import { TextMessage } from '../entities/responses/textMessage';
 import { UnpinResponse } from '../entities/responses/unpin';
 import { VideoMessage } from '../entities/responses/videoMessage';
+import { IActionWithState } from './actionWithState';
 
 export const BotResponseTypes = {
     unpin: 'unpin',
@@ -23,7 +24,8 @@ export interface IChatResponse {
     kind: keyof typeof BotResponseTypes;
     chatId: number;
     traceId: number | string;
-    sourceActionKey: string;
+
+    action: IActionWithState;
 }
 
 export interface IReplyMessage<TType> extends IChatResponse {

package/types/storage.ts

@@ -1,20 +1,20 @@
 import { ActionExecutionResult } from '../entities/actionExecutionResult';
 import { IActionState } from './actionState';
-import { IActionWithState } from './actionWithState';
+import { ActionKey, IActionWithState } from './actionWithState';
 
 export interface IStorageClient {
     updateStateFor<TActionState extends IActionState>(
-        sourceActionKey: string,
+        action: IActionWithState,
         chatId: number,
         update: (state: TActionState) => Promise<void>
     ): Promise<void>;
     close(): Promise<void>;
     load<TActionState extends IActionState>(
-        key: string
+        key: ActionKey
     ): Promise<Record<number, TActionState>>;
     saveMetadata(actions: IActionWithState[], botName: string): Promise<void>;
     getActionState<TActionState extends IActionState>(
-        entity: IActionWithState,
+        action: IActionWithState,
         chatId: number
     ): Promise<TActionState>;
     saveActionExecutionResult(