chz-telegram-bot 0.0.26 → 0.0.28

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/telegramApi.ts

@@ -1,7 +1,7 @@
-import { InputFile, Message } from 'telegraf/types';
+import { Message } from 'telegraf/types';
 import { ChatContext } from '../entities/context/chatContext';
 import { MessageContext } from '../entities/context/messageContext';
-import { reverseRecord } from '../helpers/reverseRecord';
+import { inverseRecord as inverseRecord } from '../helpers/inverseRecord';
 import { IStorageClient } from '../types/storage';
 import { Logger } from './logger';
 import { Reaction } from '../entities/responses/reaction';
@@ -28,6 +28,7 @@ export class TelegramApiService {
     telegram: Telegram;
     chats: Record<number, string>;
     storage: IStorageClient;
+    interactions: IBotApiInteractions;
 
     constructor(
         botName: string,
@@ -37,8 +38,14 @@ export class TelegramApiService {
     ) {
         this.telegram = telegram;
         this.botName = botName;
-        this.chats = reverseRecord(chats);
+        this.chats = inverseRecord(chats);
         this.storage = storage;
+
+        this.interactions = {
+            react: (reaction) => this.enqueue(reaction),
+            respond: (response) => this.enqueue(response),
+            unpin: (unpinMessage) => this.enqueue(unpinMessage)
+        } as IBotApiInteractions;
     }
 
     async flushResponses() {
@@ -80,7 +87,7 @@ export class TelegramApiService {
             );
 
             await this.storage.updateStateFor(
-                response.sourceActionKey,
+                response.action,
                 response.chatId,
                 async (state) => {
                     state.pinnedMessages.push(sentMessage.message_id);
@@ -96,7 +103,7 @@ export class TelegramApiService {
             case 'text':
                 sentMessage = await this.telegram.sendMessage(
                     response.chatId,
-                    response.content as string,
+                    response.content,
                     {
                         reply_to_message_id: response.replyId,
                         parse_mode: 'MarkdownV2',
@@ -110,7 +117,7 @@ export class TelegramApiService {
             case 'image':
                 sentMessage = await this.telegram.sendPhoto(
                     response.chatId,
-                    response.content as InputFile,
+                    response.content,
                     response.replyId
                         ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
                           ({ reply_to_message_id: response.replyId } as any)
@@ -122,7 +129,7 @@ export class TelegramApiService {
             case 'video':
                 sentMessage = await this.telegram.sendVideo(
                     response.chatId,
-                    response.content as InputFile,
+                    response.content,
                     response.replyId
                         ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
                           ({ reply_to_message_id: response.replyId } as any)
@@ -152,7 +159,7 @@ export class TelegramApiService {
                 );
 
                 await this.storage.updateStateFor(
-                    response.sourceActionKey,
+                    response.action,
                     response.chatId,
                     async (state) => {
                         state.pinnedMessages = state.pinnedMessages.filter(
@@ -168,22 +175,14 @@ export class TelegramApiService {
         this.messageQueue.push(response);
     }
 
-    private getInteractions() {
-        return {
-            react: (reaction) => this.enqueue(reaction),
-            respond: (response) => this.enqueue(response),
-            unpin: (unpinMessage) => this.enqueue(unpinMessage)
-        } as IBotApiInteractions;
-    }
-
     createContextForMessage<TActionState extends IActionState>(
         incomingMessage: IncomingMessage,
         command: CommandAction<TActionState>
     ) {
         return new MessageContext<TActionState>(
             this.botName,
-            command.key,
-            this.getInteractions(),
+            command,
+            this.interactions,
             incomingMessage,
             this.storage
         );
@@ -195,8 +194,8 @@ export class TelegramApiService {
     ) {
         return new ChatContext<TActionState>(
             this.botName,
-            scheduledAction.key,
-            this.getInteractions(),
+            scheduledAction,
+            this.interactions,
             chatId,
             this.chats[chatId],
             `Scheduled:${scheduledAction.key}:${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(