chz-telegram-bot 0.3.7 → 0.3.9

package/services/actionProcessors/commandActionProcessor.ts

@@ -4,7 +4,6 @@ import { CommandAction } from '../../entities/actions/commandAction';
 import { ReplyCaptureAction } from '../../entities/actions/replyCaptureAction';
 import { MessageContext } from '../../entities/context/messageContext';
 import { ReplyContext } from '../../entities/context/replyContext';
-import { IActionWithState } from '../../types/action';
 import { IActionState } from '../../types/actionState';
 import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';
@@ -18,17 +17,11 @@ import {
     MessageType
 } from '../../types/messageTypes';
 import { typeSafeObjectFromEntries } from '../../helpers/objectFromEntries';
+import { BaseActionProcessor } from './baseProcessor';
 
-export class CommandActionProcessor {
-    private readonly storage: IStorageClient;
-    private readonly scheduler: IScheduler;
-    private readonly logger: ILogger;
+export class CommandActionProcessor extends BaseActionProcessor {
+    private readonly replyCaptures: ReplyCaptureAction<IActionState>[] = [];
 
-    private readonly botName: string;
-    private readonly replyCaptures: ReplyCaptureAction<IActionState>[];
-
-    private api!: TelegramApiService;
-    private telegraf!: Telegraf;
     private commands = typeSafeObjectFromEntries(
         Object.values(MessageType).map((x) => [
             x,
@@ -42,12 +35,7 @@ export class CommandActionProcessor {
         scheduler: IScheduler,
         logger: ILogger
     ) {
-        this.storage = storage;
-        this.scheduler = scheduler;
-        this.logger = logger;
-
-        this.botName = botName;
-        this.replyCaptures = [];
+        super(botName, storage, scheduler, logger);
     }
 
     initialize(
@@ -56,8 +44,7 @@ export class CommandActionProcessor {
         commands: CommandAction<IActionState>[],
         verboseLoggingForIncomingMessage: boolean
     ) {
-        this.api = api;
-        this.telegraf = telegraf;
+        this.initializeDependencies(api, telegraf);
 
         for (const msgType of Object.values(MessageType)) {
             if (msgType == MessageType.Text) {
@@ -155,35 +142,25 @@ export class CommandActionProcessor {
 
         const commandsToCheck = new Set(this.commands[msg.type]);
         if (msg.type != MessageType.Text && msg.text != '') {
-            this.commands[MessageType.Text].map((x) => commandsToCheck.add(x));
+            this.commands[MessageType.Text].forEach((x) =>
+                commandsToCheck.add(x)
+            );
         }
 
         for (const commandAction of commandsToCheck) {
             this.initializeMessageContext(ctx, commandAction, msg);
-
-            try {
-                const responses = await commandAction.exec(ctx);
-                this.api.enqueueBatchedResponses(responses);
-                ctx.isInitialized = false;
-            } catch (error) {
-                ctx.logger.errorWithTraceId(error, ctx);
-            }
+            this.executeAction(commandAction, ctx);
         }
 
-        const replyCtx = new ReplyContext<IActionState>(
-            this.storage,
-            this.scheduler
-        );
-
-        for (const replyAction of this.replyCaptures) {
-            this.initializeReplyCaptureContext(replyCtx, replyAction, msg);
+        if (this.replyCaptures.length != 0) {
+            const replyCtx = new ReplyContext<IActionState>(
+                this.storage,
+                this.scheduler
+            );
 
-            try {
-                const responses = await replyAction.exec(replyCtx);
-                this.api.enqueueBatchedResponses(responses);
-                replyCtx.isInitialized = false;
-            } catch (error) {
-                replyCtx.logger.errorWithTraceId(error, replyCtx);
+            for (const replyAction of this.replyCaptures) {
+                this.initializeReplyCaptureContext(replyCtx, replyAction, msg);
+                this.executeAction(replyAction, replyCtx);
             }
         }
 
@@ -219,9 +196,9 @@ export class CommandActionProcessor {
         );
     }
 
-    private initializeMessageContext<TActionState extends IActionState>(
+    private initializeMessageContext(
         ctx: MessageContext<IActionState>,
-        action: IActionWithState<TActionState>,
+        action: CommandAction<IActionState>,
         message: IncomingMessage
     ) {
         ctx.messageId = message.messageId;

package/services/actionProcessors/inlineQueryActionProcessor.ts

@@ -9,16 +9,9 @@ import { IStorageClient } from '../../types/storage';
 import { Milliseconds } from '../../types/timeValues';
 import { TraceId } from '../../types/trace';
 import { TelegramApiService } from '../telegramApi';
+import { BaseActionProcessor } from './baseProcessor';
 
-export class InlineQueryActionProcessor {
-    private readonly storage: IStorageClient;
-    private readonly scheduler: IScheduler;
-    private readonly logger: ILogger;
-
-    private readonly botName: string;
-
-    private api!: TelegramApiService;
-    private telegraf!: Telegraf;
+export class InlineQueryActionProcessor extends BaseActionProcessor {
     private inlineQueries!: InlineQueryAction[];
 
     constructor(
@@ -27,11 +20,7 @@ export class InlineQueryActionProcessor {
         scheduler: IScheduler,
         logger: ILogger
     ) {
-        this.storage = storage;
-        this.scheduler = scheduler;
-        this.logger = logger;
-
-        this.botName = botName;
+        super(botName, storage, scheduler, logger);
     }
 
     initialize(
@@ -40,8 +29,7 @@ export class InlineQueryActionProcessor {
         inlineQueries: InlineQueryAction[],
         period: Milliseconds
     ) {
-        this.api = api;
-        this.telegraf = telegraf;
+        this.initializeDependencies(api, telegraf);
         this.inlineQueries = inlineQueries;
 
         let pendingInlineQueries: IncomingInlineQuery[] = [];
@@ -113,23 +101,19 @@ export class InlineQueryActionProcessor {
                                 inlineQuery.traceId
                             );
 
-                            try {
-                                const responses = await inlineQueryAction.exec(
-                                    ctx
-                                );
-                                this.api.enqueueBatchedResponses(responses);
-                                ctx.isInitialized = false;
-                            } catch (err) {
-                                const error = err as Error;
-
-                                if (error.name == 'AbortError') {
-                                    ctx.logger.logWithTraceId(
-                                        `Aborting query ${inlineQuery.queryId} (${inlineQuery.query}) successful.`
-                                    );
-                                } else {
-                                    ctx.logger.errorWithTraceId(error, ctx);
+                            this.executeAction(
+                                inlineQueryAction,
+                                ctx,
+                                (error, ctx) => {
+                                    if (error.name == 'AbortError') {
+                                        ctx.logger.logWithTraceId(
+                                            `Aborting query ${inlineQuery.queryId} (${inlineQuery.query}) successful.`
+                                        );
+                                    } else {
+                                        ctx.logger.errorWithTraceId(error, ctx);
+                                    }
                                 }
-                            }
+                            );
                         }
 
                         queriesInProcessing.delete(inlineQuery.userId);

package/services/actionProcessors/scheduledActionProcessor.ts

@@ -4,7 +4,6 @@ import { ScheduledAction } from '../../entities/actions/scheduledAction';
 import { ChatContext } from '../../entities/context/chatContext';
 import { secondsToMilliseconds } from '../../helpers/timeConvertions';
 import { createTrace } from '../../helpers/traceFactory';
-import { IActionWithState } from '../../types/action';
 import { IActionState } from '../../types/actionState';
 import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';
@@ -12,16 +11,11 @@ import { IStorageClient } from '../../types/storage';
 import { Seconds, Milliseconds } from '../../types/timeValues';
 import { TraceId } from '../../types/trace';
 import { TelegramApiService } from '../telegramApi';
+import { BaseActionProcessor } from './baseProcessor';
 
-export class ScheduledActionProcessor {
-    private readonly storage: IStorageClient;
-    private readonly scheduler: IScheduler;
-    private readonly logger: ILogger;
-
-    private readonly botName: string;
+export class ScheduledActionProcessor extends BaseActionProcessor {
     private readonly chats: Record<string, number>;
 
-    private api!: TelegramApiService;
     private scheduled!: ScheduledAction<IActionState>[];
 
     constructor(
@@ -31,11 +25,7 @@ export class ScheduledActionProcessor {
         scheduler: IScheduler,
         logger: ILogger
     ) {
-        this.storage = storage;
-        this.scheduler = scheduler;
-        this.logger = logger;
-
-        this.botName = botName;
+        super(botName, storage, scheduler, logger);
         this.chats = chats;
     }
 
@@ -44,7 +34,7 @@ export class ScheduledActionProcessor {
         scheduled: ScheduledAction<IActionState>[],
         period: Seconds
     ) {
-        this.api = api;
+        this.initializeDependencies(api, null!);
         this.scheduled = scheduled;
 
         if (this.scheduled.length > 0) {
@@ -106,22 +96,16 @@ export class ScheduledActionProcessor {
                     )
                 );
 
-                try {
-                    const responses = await scheduledAction.exec(ctx);
-                    this.api.enqueueBatchedResponses(responses);
-                    ctx.isInitialized = false;
-                } catch (error) {
-                    ctx.logger.errorWithTraceId(error, ctx);
-                }
+                this.executeAction(scheduledAction, ctx);
             }
         }
 
         this.api.flushResponses();
     }
 
-    private initializeChatContext<TActionState extends IActionState>(
+    private initializeChatContext(
         ctx: ChatContext<IActionState>,
-        action: IActionWithState<TActionState>,
+        action: ScheduledAction<IActionState>,
         chatInfo: ChatInfo,
         traceId: TraceId
     ) {

package/services/jsonFileStorage.ts

@@ -5,7 +5,12 @@ import { IStorageClient } from '../types/storage';
 import { IActionState } from '../types/actionState';
 import { IActionWithState, ActionKey } from '../types/action';
 
+function buildPath(storagePath: string, botName: string, actionKey: string) {
+    return `${storagePath}/${botName}/${actionKey.replaceAll(':', '/')}.json`;
+}
+
 export class JsonFileStorage implements IStorageClient {
+    private readonly filePaths = new Map<ActionKey, string>();
     private readonly locks = new Map<ActionKey, Semaphore>();
     private readonly cache: Map<string, Record<number, IActionState>>;
     private readonly storagePath: string;
@@ -28,6 +33,10 @@ export class JsonFileStorage implements IStorageClient {
 
         for (const action of actions) {
             this.locks.set(action.key, new Semaphore(1));
+            this.filePaths.set(
+                action.key,
+                buildPath(this.storagePath, this.botName, action.key)
+            );
         }
     }
 
@@ -45,58 +54,61 @@ export class JsonFileStorage implements IStorageClient {
         }
     }
 
-    private async loadInternal<TActionState extends IActionState>(
+    private tryGetFromCache<TActionState extends IActionState>(key: ActionKey) {
+        return this.cache.get(key) as Record<number, TActionState> | undefined;
+    }
+
+    private async loadFromFile<TActionState extends IActionState>(
         key: ActionKey
     ) {
-        if (!this.cache.has(key)) {
-            const targetPath = this.buidPathFromKey(key);
+        if (!this.filePaths.has(key))
+            this.filePaths.set(
+                key,
+                buildPath(this.storagePath, this.botName, key)
+            );
+        const targetPath = this.filePaths.get(key)!;
 
-            const fileContent = await readFile(targetPath, {
-                encoding: 'utf-8',
-                flag: 'a+'
-            });
+        const fileContent = await readFile(targetPath, {
+            encoding: 'utf-8',
+            flag: 'a+'
+        });
 
-            if (fileContent) {
-                const data = JSON.parse(fileContent);
+        if (fileContent) {
+            const data = JSON.parse(fileContent);
 
-                this.cache.set(key, data);
-            }
+            this.cache.set(key, data);
         }
 
         return (this.cache.get(key) ?? {}) as Record<number, TActionState>;
     }
 
-    private async save<TActionState extends IActionState>(
+    private async updateCacheAndSaveToFile<TActionState extends IActionState>(
         data: Record<number, TActionState>,
         key: ActionKey
     ) {
         this.cache.set(key, data);
 
-        const targetPath = this.buidPathFromKey(key);
+        if (!this.filePaths.has(key))
+            this.filePaths.set(
+                key,
+                buildPath(this.storagePath, this.botName, key)
+            );
+        const targetPath = this.filePaths.get(key)!;
 
         await writeFile(targetPath, JSON.stringify(data), { flag: 'w+' });
     }
 
-    private buidPathFromKey(key: ActionKey) {
-        return `${this.storagePath}/${this.botName}/${key.replaceAll(
-            ':',
-            '/'
-        )}.json`;
-    }
-
     async load<TActionState extends IActionState>(key: ActionKey) {
-        return await this.lock(key, async () => {
-            return await this.loadInternal<TActionState>(key);
-        });
+        return (
+            this.tryGetFromCache<TActionState>(key) ??
+            (await this.lock(key, async () => {
+                return await this.loadFromFile<TActionState>(key);
+            }))
+        );
     }
 
-    async saveMetadata(
-        actions: IActionWithState<IActionState>[],
-        botName: string
-    ) {
-        const targetPath = this.buidPathFromKey(
-            `Metadata-${botName}` as ActionKey
-        );
+    async saveMetadata(actions: IActionWithState<IActionState>[]) {
+        const targetPath = `${this.storagePath}/${this.botName}/Metadata-${this.botName}.json`;
 
         await writeFile(targetPath, JSON.stringify(actions), {
             flag: 'w+'
@@ -107,14 +119,13 @@ export class JsonFileStorage implements IStorageClient {
         action: IActionWithState<TActionState>,
         chatId: number
     ) {
-        return await this.lock(action.key, async () => {
-            const data = await this.loadInternal(action.key);
+        const value =
+            this.tryGetFromCache<TActionState>(action.key) ??
+            (await this.lock(action.key, async () => {
+                return await this.loadFromFile<TActionState>(action.key);
+            }));
 
-            return Object.assign(
-                action.stateConstructor(),
-                data[chatId]
-            ) as TActionState;
-        });
+        return Object.assign(action.stateConstructor(), value[chatId]);
     }
 
     async saveActionExecutionResult<TActionState extends IActionState>(
@@ -123,11 +134,13 @@ export class JsonFileStorage implements IStorageClient {
         state: TActionState
     ) {
         return await this.lock(action.key, async () => {
-            const data = await this.loadInternal<TActionState>(action.key);
+            const data =
+                this.tryGetFromCache<TActionState>(action.key) ??
+                (await this.loadFromFile<TActionState>(action.key));
 
             data[chatId] = state;
 
-            await this.save(data, action.key);
+            await this.updateCacheAndSaveToFile(data, action.key);
         });
     }
 
@@ -143,7 +156,10 @@ export class JsonFileStorage implements IStorageClient {
         update: (state: TActionState) => Promise<void>
     ) {
         await this.lock(action.key, async () => {
-            const data = await this.loadInternal<TActionState>(action.key);
+            const data =
+                this.tryGetFromCache<TActionState>(action.key) ??
+                (await this.loadFromFile<TActionState>(action.key));
+
             const state = Object.assign(
                 action.stateConstructor(),
                 data[chatId]
@@ -151,7 +167,7 @@ export class JsonFileStorage implements IStorageClient {
 
             await update(state);
 
-            await this.save(data, action.key);
+            await this.updateCacheAndSaveToFile(data, action.key);
         });
     }
 }

package/types/action.ts

@@ -1,4 +1,6 @@
+import { BaseContext } from '../entities/context/baseContext';
 import { IActionState } from './actionState';
+import { BotResponse } from './response';
 
 export type ActionKey = string & { __brand: 'actionKey' };
 
@@ -9,4 +11,5 @@ export interface IActionWithState<TActionState extends IActionState>
 
 export interface IAction {
     readonly key: ActionKey;
+    exec(ctx: BaseContext<IAction>): Promise<BotResponse[]>;
 }

package/types/storage.ts

@@ -12,8 +12,7 @@ export interface IStorageClient {
         key: ActionKey
     ): Promise<Record<number, TActionState>>;
     saveMetadata<TActionState extends IActionState>(
-        actions: IActionWithState<TActionState>[],
-        botName: string
+        actions: IActionWithState<TActionState>[]
     ): Promise<void>;
     getActionState<TActionState extends IActionState>(
         action: IActionWithState<TActionState>,