chz-telegram-bot 0.5.4 → 0.6.8

package/dist/main.js

@@ -0,0 +1,33 @@
+import { readFile } from 'fs/promises';
+import { BotInstance } from './entities/botInstance';
+class BotOrchestrator {
+    bots = [];
+    /**
+     * Starts bot
+     */
+    async startBot(options) {
+        const token = await readFile(options.tokenFilePath, 'utf8');
+        const bot = new BotInstance({
+            name: options.name,
+            actions: options.actions,
+            chats: options.chats,
+            services: {
+                storageClient: options.services?.storageClient,
+                scheduler: options.services?.scheduler
+            },
+            storagePath: options.storagePath
+        });
+        await bot.start(token, options.actions, options.scheduledPeriod);
+        this.bots.push(bot);
+        return bot;
+    }
+    /**
+     * Terminates all scheduled tasks, closes storage connections and stops all bots.
+     */
+    async stopBots() {
+        for (const bot of this.bots) {
+            await bot.stop();
+        }
+    }
+}
+export const botOrchestrator = new BotOrchestrator();

package/dist/services/actionProcessingService.d.ts

@@ -0,0 +1,25 @@
+import { Seconds } from '../types/timeValues';
+import { IScheduler } from '../types/scheduler';
+import { IStorageClient } from '../types/storage';
+import { InlineQueryAction } from '../entities/actions/inlineQueryAction';
+import { IActionState } from '../types/actionState';
+import { CommandAction } from '../entities/actions/commandAction';
+import { ScheduledAction } from '../entities/actions/scheduledAction';
+import { TypedEventEmitter } from '../types/events';
+export declare class ActionProcessingService {
+    private readonly eventEmitter;
+    private readonly storage;
+    private readonly commandProcessor;
+    private readonly scheduledProcessor;
+    private readonly inlineQueryProcessor;
+    private readonly botName;
+    private telegramBot;
+    constructor(botName: string, chats: Record<string, number>, storage: IStorageClient, scheduler: IScheduler, eventEmitter: TypedEventEmitter);
+    initialize(token: string, actions: {
+        commands: CommandAction<IActionState>[];
+        scheduled: ScheduledAction<IActionState>[];
+        inlineQueries: InlineQueryAction[];
+    }, scheduledPeriod?: Seconds): Promise<void>;
+    stop(): void;
+}
+//# sourceMappingURL=actionProcessingService.d.ts.map

package/dist/services/actionProcessingService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionProcessingService.d.ts","sourceRoot":"","sources":["../../services/actionProcessingService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAuB,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAOtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,qBAAa,uBAAuB;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAyB;IAC1D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA2B;IAC9D,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA6B;IAElE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,OAAO,CAAC,WAAW,CAAe;gBAG9B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,iBAAiB;IA4B7B,UAAU,CACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;QACL,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,EAAE,CAAC;QACxC,SAAS,EAAE,eAAe,CAAC,YAAY,CAAC,EAAE,CAAC;QAC3C,aAAa,EAAE,iBAAiB,EAAE,CAAC;KACtC,EACD,eAAe,CAAC,EAAE,OAAO;IAyD7B,IAAI;CAGP"}

package/dist/services/actionProcessingService.js

@@ -0,0 +1,50 @@
+import { hoursToSeconds } from '../helpers/timeConvertions';
+import { TelegramApiService } from './telegramApi';
+import { buildHelpCommand } from '../builtin/helpAction';
+import { CommandActionProcessor } from './actionProcessors/commandActionProcessor';
+import { InlineQueryActionProcessor } from './actionProcessors/inlineQueryActionProcessor';
+import { ScheduledActionProcessor } from './actionProcessors/scheduledActionProcessor';
+import { Telegraf } from 'telegraf';
+export class ActionProcessingService {
+    eventEmitter;
+    storage;
+    commandProcessor;
+    scheduledProcessor;
+    inlineQueryProcessor;
+    botName;
+    telegramBot;
+    constructor(botName, chats, storage, scheduler, eventEmitter) {
+        this.storage = storage;
+        this.eventEmitter = eventEmitter;
+        this.commandProcessor = new CommandActionProcessor(botName, storage, scheduler, this.eventEmitter);
+        this.scheduledProcessor = new ScheduledActionProcessor(botName, chats, storage, scheduler, this.eventEmitter);
+        this.inlineQueryProcessor = new InlineQueryActionProcessor(botName, storage, scheduler, this.eventEmitter);
+        this.botName = botName;
+    }
+    async initialize(token, actions, scheduledPeriod) {
+        this.telegramBot = new Telegraf(token);
+        const api = new TelegramApiService(this.botName, this.telegramBot.telegram, this.storage, this.eventEmitter, (capture, id, chatInfo) => {
+            this.commandProcessor.captureRegistrationCallback(capture, id, chatInfo);
+        });
+        const botInfo = await this.telegramBot.telegram.getMe();
+        const commandActions = actions.commands.length > 0 && botInfo.username
+            ? [
+                buildHelpCommand(actions.commands
+                    .map((x) => x.readmeFactory(botInfo.username))
+                    .filter((x) => !!x), botInfo.username),
+                ...actions.commands
+            ]
+            : [];
+        this.commandProcessor.initialize(api, this.telegramBot, commandActions, botInfo);
+        this.inlineQueryProcessor.initialize(api, this.telegramBot, actions.inlineQueries, 300);
+        this.scheduledProcessor.initialize(api, actions.scheduled, scheduledPeriod ?? hoursToSeconds(1));
+        void this.telegramBot.launch();
+        void this.storage.saveMetadata([
+            ...actions.scheduled,
+            ...commandActions
+        ]);
+    }
+    stop() {
+        this.telegramBot.stop();
+    }
+}

package/dist/services/actionProcessors/baseProcessor.d.ts

@@ -0,0 +1,18 @@
+import { IScheduler } from '../../types/scheduler';
+import { IStorageClient } from '../../types/storage';
+import { TelegramApiService } from '../telegramApi';
+import { IAction } from '../../types/action';
+import { BaseContextInternal } from '../../entities/context/baseContext';
+import { TypedEventEmitter } from '../../types/events';
+export declare abstract class BaseActionProcessor {
+    protected readonly storage: IStorageClient;
+    protected readonly scheduler: IScheduler;
+    protected readonly eventEmitter: TypedEventEmitter;
+    protected readonly botName: string;
+    protected api: TelegramApiService;
+    constructor(botName: string, storage: IStorageClient, scheduler: IScheduler, eventEmitter: TypedEventEmitter);
+    private defaultErrorHandler;
+    initializeDependencies(api: TelegramApiService): void;
+    executeAction<TAction extends IAction, TActionContext extends BaseContextInternal<TAction>>(action: TAction, ctx: TActionContext, errorHandler?: (error: Error, ctx: TActionContext) => void): Promise<void>;
+}
+//# sourceMappingURL=baseProcessor.d.ts.map

package/dist/services/actionProcessors/baseProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseProcessor.d.ts","sourceRoot":"","sources":["../../../services/actionProcessors/baseProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAgB,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAErE,8BAAsB,mBAAmB;IACrC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IAC3C,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IACzC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC;IAEnD,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEnC,SAAS,CAAC,GAAG,EAAG,kBAAkB,CAAC;gBAG/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,iBAAiB;IASnC,OAAO,CAAC,mBAAmB;IAI3B,sBAAsB,CAAC,GAAG,EAAE,kBAAkB;IAIxC,aAAa,CACf,OAAO,SAAS,OAAO,EACvB,cAAc,SAAS,mBAAmB,CAAC,OAAO,CAAC,EAEnD,MAAM,EAAE,OAAO,EACf,GAAG,EAAE,cAAc,EACnB,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,cAAc,KAAK,IAAI;CAajE"}

package/dist/services/actionProcessors/baseProcessor.js

@@ -0,0 +1,33 @@
+import { BotEventType } from '../../types/events';
+export class BaseActionProcessor {
+    storage;
+    scheduler;
+    eventEmitter;
+    botName;
+    api;
+    constructor(botName, storage, scheduler, eventEmitter) {
+        this.storage = storage;
+        this.scheduler = scheduler;
+        this.eventEmitter = eventEmitter;
+        this.botName = botName;
+    }
+    defaultErrorHandler(error) {
+        this.eventEmitter.emit(BotEventType.error, { error });
+    }
+    initializeDependencies(api) {
+        this.api = api;
+    }
+    async executeAction(action, ctx, errorHandler) {
+        try {
+            const responses = await action.exec(ctx);
+            this.api.enqueueBatchedResponses(responses);
+            ctx.isInitialized = false;
+        }
+        catch (error) {
+            (errorHandler ?? this.defaultErrorHandler)(error, ctx);
+            this.eventEmitter.emit(BotEventType.error, {
+                error: error
+            });
+        }
+    }
+}

package/dist/services/actionProcessors/commandActionProcessor.d.ts

@@ -0,0 +1,19 @@
+import { CommandAction } from '../../entities/actions/commandAction';
+import { IActionState } from '../../types/actionState';
+import { TelegramApiService } from '../telegramApi';
+import { IReplyCapture } from '../../types/capture';
+import { ChatInfo } from '../../dtos/chatInfo';
+import { BaseActionProcessor } from './baseProcessor';
+import { BotInfo, TelegramBot } from '../../types/externalAliases';
+export declare class CommandActionProcessor extends BaseActionProcessor {
+    private readonly replyCaptures;
+    private readonly chatHistory;
+    private botInfo;
+    private commands;
+    initialize(api: TelegramApiService, telegram: TelegramBot, commands: CommandAction<IActionState>[], botInfo: BotInfo): void;
+    captureRegistrationCallback(capture: IReplyCapture, parentMessageId: number, chatInfo: ChatInfo): void;
+    private processMessage;
+    private initializeReplyCaptureContext;
+    private initializeMessageContext;
+}
+//# sourceMappingURL=commandActionProcessor.d.ts.map

package/dist/services/actionProcessors/commandActionProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandActionProcessor.d.ts","sourceRoot":"","sources":["../../../services/actionProcessors/commandActionProcessor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAIrE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAM/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAKtD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAKnE,qBAAa,sBAAuB,SAAQ,mBAAmB;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0C;IACxE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2C;IACvE,OAAO,CAAC,OAAO,CAAW;IAE1B,OAAO,CAAC,QAAQ,CAKd;IAEF,UAAU,CACN,GAAG,EAAE,kBAAkB,EACvB,QAAQ,EAAE,WAAW,EACrB,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,EAAE,EACvC,OAAO,EAAE,OAAO;IAoDpB,2BAA2B,CACvB,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,QAAQ;YA4BR,cAAc;IAkE5B,OAAO,CAAC,6BAA6B;IA2BrC,OAAO,CAAC,wBAAwB;CA6BnC"}

package/dist/services/actionProcessors/commandActionProcessor.js

@@ -0,0 +1,130 @@
+import { IncomingMessage } from '../../dtos/incomingMessage';
+import { ReplyCaptureAction } from '../../entities/actions/replyCaptureAction';
+import { MessageContextInternal } from '../../entities/context/messageContext';
+import { ReplyContextInternal } from '../../entities/context/replyContext';
+import { INTERNAL_MESSAGE_TYPE_PREFIX, MessageType } from '../../types/messageTypes';
+import { typeSafeObjectFromEntries } from '../../helpers/objectFromEntries';
+import { BaseActionProcessor } from './baseProcessor';
+import { getOrSetIfNotExists } from '../../helpers/mapUtils';
+import { MessageInfo } from '../../dtos/messageInfo';
+import { UserInfo } from '../../dtos/userInfo';
+import { ChatHistoryMessage } from '../../dtos/chatHistoryMessage';
+import { BotEventType } from '../../types/events';
+const MESSAGE_HISTORY_LENGTH_LIMIT = 100;
+export class CommandActionProcessor extends BaseActionProcessor {
+    replyCaptures = [];
+    chatHistory = new Map();
+    botInfo;
+    commands = typeSafeObjectFromEntries(Object.values(MessageType).map((x) => [
+        x,
+        []
+    ]));
+    initialize(api, telegram, commands, botInfo) {
+        this.botInfo = botInfo;
+        this.initializeDependencies(api);
+        for (const msgType of Object.values(MessageType)) {
+            if (msgType == MessageType.Text) {
+                this.commands[msgType] = commands.filter((cmd) => cmd.triggers.some((x) => typeof x != 'string') ||
+                    cmd.triggers.some((x) => typeof x == 'string' &&
+                        !x.startsWith(INTERNAL_MESSAGE_TYPE_PREFIX)) ||
+                    cmd.triggers.includes(MessageType.Text) ||
+                    cmd.triggers.includes(MessageType.Any));
+                continue;
+            }
+            this.commands[msgType] = commands.filter((cmd) => cmd.triggers.includes(msgType) ||
+                cmd.triggers.includes(MessageType.Any));
+        }
+        if (commands.length > 0) {
+            telegram.on('message', async ({ message }) => {
+                const internalMessage = new IncomingMessage(message, this.botName, getOrSetIfNotExists(this.chatHistory, message.chat.id, []));
+                this.eventEmitter.emit(BotEventType.messageRecieved, {
+                    botInfo: this.botInfo,
+                    message: internalMessage
+                });
+                await this.processMessage(internalMessage);
+                this.eventEmitter.emit(BotEventType.messageProcessingFinished, {
+                    botInfo: this.botInfo,
+                    message: internalMessage
+                });
+            });
+        }
+    }
+    captureRegistrationCallback(capture, parentMessageId, chatInfo) {
+        const replyAction = new ReplyCaptureAction(parentMessageId, capture.action, capture.handler, capture.trigger, capture.abortController);
+        this.eventEmitter.emit(BotEventType.commandActionCaptureStarted, {
+            parentMessageId,
+            chatInfo
+        });
+        this.replyCaptures.push(replyAction);
+        capture.abortController.signal.addEventListener('abort', () => {
+            const index = this.replyCaptures.indexOf(replyAction);
+            this.replyCaptures.splice(index, 1);
+            this.eventEmitter.emit(BotEventType.commandActionCaptureAborted, {
+                parentMessageId,
+                chatInfo
+            });
+        });
+    }
+    async processMessage(msg) {
+        this.eventEmitter.emit(BotEventType.messageProcessingStarted, {
+            botInfo: this.botInfo,
+            message: msg
+        });
+        const chatHistoryArray = getOrSetIfNotExists(this.chatHistory, msg.chatInfo.id, []);
+        while (chatHistoryArray.length > MESSAGE_HISTORY_LENGTH_LIMIT)
+            chatHistoryArray.shift();
+        chatHistoryArray.push(new ChatHistoryMessage(msg.messageId, msg.from, msg.text, msg.type, msg.traceId, msg.replyToMessageId, msg.updateObject.date));
+        const ctx = new MessageContextInternal(this.storage, this.scheduler, this.eventEmitter);
+        const commandsToCheck = new Set(this.commands[msg.type]);
+        if (msg.type != MessageType.Text && msg.text != '') {
+            for (const command of this.commands[MessageType.Text]) {
+                commandsToCheck.add(command);
+            }
+        }
+        this.eventEmitter.emit(BotEventType.beforeActionsExecuting, {
+            botInfo: this.botInfo,
+            message: msg,
+            commands: commandsToCheck
+        });
+        for (const commandAction of commandsToCheck) {
+            this.initializeMessageContext(ctx, commandAction, msg);
+            await this.executeAction(commandAction, ctx);
+        }
+        if (this.replyCaptures.length != 0) {
+            const replyCtx = new ReplyContextInternal(this.storage, this.scheduler, this.eventEmitter);
+            for (const replyAction of this.replyCaptures) {
+                this.initializeReplyCaptureContext(replyCtx, replyAction, msg);
+                await this.executeAction(replyAction, replyCtx);
+            }
+        }
+        this.api.flushResponses();
+    }
+    initializeReplyCaptureContext(ctx, action, message) {
+        ctx.replyMessageId = message.replyToMessageId;
+        ctx.messageInfo = new MessageInfo(message.messageId, message.text, message.type, message.updateObject);
+        ctx.userInfo = new UserInfo(message.from?.id ?? -1, (message.from?.first_name ?? 'Unknown user') +
+            (message.from?.last_name ? ` ${message.from.last_name}` : ''));
+        ctx.botName = this.botName;
+        ctx.action = action;
+        ctx.chatInfo = message.chatInfo;
+        ctx.traceId = message.traceId;
+        ctx.botInfo = this.botInfo;
+        ctx.isInitialized = true;
+        ctx.matchResults = [];
+    }
+    initializeMessageContext(ctx, action, message) {
+        ctx.messageInfo = new MessageInfo(message.messageId, message.text, message.type, message.updateObject);
+        ctx.userInfo = new UserInfo(message.from?.id ?? -1, (message.from?.first_name ?? 'Unknown user') +
+            (message.from?.last_name ? ` ${message.from.last_name}` : ''));
+        ctx.matchResults = [];
+        ctx.startCooldown = true;
+        ctx.responses = [];
+        ctx.isInitialized = true;
+        ctx.botName = this.botName;
+        ctx.action = action;
+        ctx.chatInfo = message.chatInfo;
+        ctx.traceId = message.traceId;
+        ctx.botInfo = this.botInfo;
+        ctx.customCooldown = undefined;
+    }
+}

package/dist/services/actionProcessors/inlineQueryActionProcessor.d.ts

@@ -0,0 +1,11 @@
+import { InlineQueryAction } from '../../entities/actions/inlineQueryAction';
+import { TelegramBot } from '../../types/externalAliases';
+import { Milliseconds } from '../../types/timeValues';
+import { TelegramApiService } from '../telegramApi';
+import { BaseActionProcessor } from './baseProcessor';
+export declare class InlineQueryActionProcessor extends BaseActionProcessor {
+    private inlineQueries;
+    initialize(api: TelegramApiService, telegram: TelegramBot, inlineQueries: InlineQueryAction[], period: Milliseconds): void;
+    private initializeInlineQueryContext;
+}
+//# sourceMappingURL=inlineQueryActionProcessor.d.ts.map

package/dist/services/actionProcessors/inlineQueryActionProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineQueryActionProcessor.d.ts","sourceRoot":"","sources":["../../../services/actionProcessors/inlineQueryActionProcessor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAI7E,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEtD,qBAAa,0BAA2B,SAAQ,mBAAmB;IAC/D,OAAO,CAAC,aAAa,CAAuB;IAE5C,UAAU,CACN,GAAG,EAAE,kBAAkB,EACvB,QAAQ,EAAE,WAAW,EACrB,aAAa,EAAE,iBAAiB,EAAE,EAClC,MAAM,EAAE,YAAY;IA4GxB,OAAO,CAAC,4BAA4B;CAmBvC"}

package/dist/services/actionProcessors/inlineQueryActionProcessor.js

@@ -0,0 +1,69 @@
+import { IncomingInlineQuery } from '../../dtos/incomingQuery';
+import { InlineQueryContextInternal } from '../../entities/context/inlineQueryContext';
+import { createTrace } from '../../helpers/traceFactory';
+import { BotEventType } from '../../types/events';
+import { BaseActionProcessor } from './baseProcessor';
+export class InlineQueryActionProcessor extends BaseActionProcessor {
+    inlineQueries;
+    initialize(api, telegram, inlineQueries, period) {
+        this.initializeDependencies(api);
+        this.inlineQueries = inlineQueries;
+        let pendingInlineQueries = [];
+        const queriesInProcessing = new Map();
+        if (this.inlineQueries.length > 0) {
+            telegram.on('inline_query', ({ inlineQuery }) => {
+                const query = new IncomingInlineQuery(inlineQuery.id, inlineQuery.query, inlineQuery.from.id, createTrace('InlineQuery', this.botName, inlineQuery.id));
+                this.eventEmitter.emit(BotEventType.inlineProcessingStarted, {
+                    query
+                });
+                const queryBeingProcessed = queriesInProcessing.get(query.userId);
+                if (queryBeingProcessed) {
+                    this.eventEmitter.emit(BotEventType.inlineProcessingAborting, {
+                        newQuery: query,
+                        abortedQuery: queryBeingProcessed
+                    });
+                    queryBeingProcessed.abortController.abort();
+                    queriesInProcessing.delete(query.userId);
+                }
+                pendingInlineQueries = pendingInlineQueries.filter((q) => q.userId != query.userId);
+                pendingInlineQueries.push(query);
+            });
+            this.scheduler.createTask('InlineQueryProcessing', async () => {
+                const ctx = new InlineQueryContextInternal(this.storage, this.scheduler, this.eventEmitter);
+                const queriesToProcess = [...pendingInlineQueries];
+                pendingInlineQueries = [];
+                for (const inlineQuery of queriesToProcess) {
+                    queriesInProcessing.set(inlineQuery.userId, inlineQuery);
+                    for (const inlineQueryAction of this.inlineQueries) {
+                        this.initializeInlineQueryContext(ctx, inlineQuery.query, inlineQuery.queryId, inlineQueryAction, inlineQuery.abortController.signal, inlineQuery.traceId);
+                        await this.executeAction(inlineQueryAction, ctx, (error, _) => {
+                            if (error.name == 'AbortError') {
+                                this.eventEmitter.emit(BotEventType.inlineProcessingAborted, {
+                                    abortedQuery: inlineQuery
+                                });
+                            }
+                            else {
+                                this.eventEmitter.emit(BotEventType.error, {
+                                    error
+                                });
+                            }
+                        });
+                    }
+                    queriesInProcessing.delete(inlineQuery.userId);
+                }
+                this.api.flushResponses();
+            }, period, false, this.botName);
+        }
+    }
+    initializeInlineQueryContext(ctx, queryText, queryId, action, abortSignal, traceId) {
+        ctx.queryText = queryText;
+        ctx.queryId = queryId;
+        ctx.botName = this.botName;
+        ctx.action = action;
+        ctx.traceId = traceId;
+        ctx.abortSignal = abortSignal;
+        ctx.isInitialized = true;
+        ctx.queryResults = [];
+        ctx.matchResults = [];
+    }
+}

package/dist/services/actionProcessors/scheduledActionProcessor.d.ts

@@ -0,0 +1,17 @@
+import { ScheduledAction } from '../../entities/actions/scheduledAction';
+import { IActionState } from '../../types/actionState';
+import { IScheduler } from '../../types/scheduler';
+import { IStorageClient } from '../../types/storage';
+import { Seconds } from '../../types/timeValues';
+import { TelegramApiService } from '../telegramApi';
+import { BaseActionProcessor } from './baseProcessor';
+import { TypedEventEmitter } from '../../types/events';
+export declare class ScheduledActionProcessor extends BaseActionProcessor {
+    private readonly chats;
+    private scheduled;
+    constructor(botName: string, chats: Record<string, number>, storage: IStorageClient, scheduler: IScheduler, eventEmitter: TypedEventEmitter);
+    initialize(api: TelegramApiService, scheduled: ScheduledAction<IActionState>[], period: Seconds): void;
+    private runScheduled;
+    private initializeChatContext;
+}
+//# sourceMappingURL=scheduledActionProcessor.d.ts.map

package/dist/services/actionProcessors/scheduledActionProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduledActionProcessor.d.ts","sourceRoot":"","sources":["../../../services/actionProcessors/scheduledActionProcessor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAIzE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAgB,MAAM,wBAAwB,CAAC;AAE/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,qBAAa,wBAAyB,SAAQ,mBAAmB;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAE/C,OAAO,CAAC,SAAS,CAAmC;gBAGhD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,iBAAiB;IAMnC,UAAU,CACN,GAAG,EAAE,kBAAkB,EACvB,SAAS,EAAE,eAAe,CAAC,YAAY,CAAC,EAAE,EAC1C,MAAM,EAAE,OAAO;YAgDL,YAAY;IA2B1B,OAAO,CAAC,qBAAqB;CAahC"}

package/dist/services/actionProcessors/scheduledActionProcessor.js

@@ -0,0 +1,55 @@
+import moment from 'moment';
+import { ChatInfo } from '../../dtos/chatInfo';
+import { ChatContextInternal } from '../../entities/context/chatContext';
+import { secondsToMilliseconds } from '../../helpers/timeConvertions';
+import { createTrace } from '../../helpers/traceFactory';
+import { BaseActionProcessor } from './baseProcessor';
+export class ScheduledActionProcessor extends BaseActionProcessor {
+    chats;
+    scheduled;
+    constructor(botName, chats, storage, scheduler, eventEmitter) {
+        super(botName, storage, scheduler, eventEmitter);
+        this.chats = chats;
+    }
+    initialize(api, scheduled, period) {
+        this.initializeDependencies(api);
+        this.scheduled = scheduled;
+        if (this.scheduled.length > 0) {
+            const now = moment();
+            if (now.minute() == 0 && now.second() == 0) {
+                this.scheduler.createTask('ScheduledProcessing', async () => {
+                    await this.runScheduled();
+                }, secondsToMilliseconds(period), true, this.botName);
+                return;
+            }
+            let nextExecutionTime = now.clone().startOf('hour');
+            if (now.minute() > 0 || now.second() > 0) {
+                nextExecutionTime = nextExecutionTime.add(1, 'hour');
+            }
+            const delay = nextExecutionTime.diff(now);
+            this.scheduler.createOnetimeTask('ScheduledProcessing_OneTime', () => {
+                this.scheduler.createTask('ScheduledProcessing', () => {
+                    void this.runScheduled();
+                }, secondsToMilliseconds(period), true, this.botName);
+            }, delay, this.botName);
+        }
+    }
+    async runScheduled() {
+        const ctx = new ChatContextInternal(this.storage, this.scheduler, this.eventEmitter);
+        for (const [chatName, chatId] of Object.entries(this.chats)) {
+            for (const scheduledAction of this.scheduled) {
+                this.initializeChatContext(ctx, scheduledAction, new ChatInfo(chatId, chatName, []), createTrace(scheduledAction, this.botName, `${scheduledAction.key}-${chatId}`));
+                await this.executeAction(scheduledAction, ctx);
+            }
+        }
+        this.api.flushResponses();
+    }
+    initializeChatContext(ctx, action, chatInfo, traceId) {
+        ctx.responses = [];
+        ctx.isInitialized = true;
+        ctx.botName = this.botName;
+        ctx.action = action;
+        ctx.chatInfo = chatInfo;
+        ctx.traceId = traceId;
+    }
+}

package/dist/services/jsonFileStorage.d.ts

@@ -0,0 +1,25 @@
+import { IStorageClient } from '../types/storage';
+import { IActionState } from '../types/actionState';
+import { IActionWithState, ActionKey } from '../types/action';
+import { TypedEventEmitter } from '../types/events';
+export declare class JsonFileStorage implements IStorageClient {
+    private readonly eventEmitter;
+    private readonly filePaths;
+    private readonly locks;
+    private readonly cache;
+    private readonly storagePath;
+    private readonly botName;
+    constructor(botName: string, actions: IActionWithState<IActionState>[], eventEmitter: TypedEventEmitter, path?: string);
+    private backfillEmptyActionStates;
+    private lock;
+    private tryGetFromCache;
+    private loadFromFile;
+    private updateCacheAndSaveToFile;
+    load<TActionState extends IActionState>(key: ActionKey): Promise<Record<number, TActionState | undefined>>;
+    saveMetadata(actions: IActionWithState<IActionState>[]): Promise<void>;
+    getActionState<TActionState extends IActionState>(action: IActionWithState<TActionState>, chatId: number): Promise<TActionState | (TActionState & undefined)>;
+    saveActionExecutionResult<TActionState extends IActionState>(action: IActionWithState<TActionState>, chatId: number, state: TActionState): Promise<void>;
+    close(): Promise<void>;
+    updateStateFor<TActionState extends IActionState>(action: IActionWithState<TActionState>, chatId: number, update: (state: TActionState) => Promise<void> | void): Promise<void>;
+}
+//# sourceMappingURL=jsonFileStorage.d.ts.map

package/dist/services/jsonFileStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonFileStorage.d.ts","sourceRoot":"","sources":["../../services/jsonFileStorage.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,EAAgB,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAMlE,qBAAa,eAAgB,YAAW,cAAc;IAClD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAC1D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;IACzD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4C;IAClE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAG7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,CAAC,YAAY,CAAC,EAAE,EACzC,YAAY,EAAE,iBAAiB,EAC/B,IAAI,CAAC,EAAE,MAAM;IAsBjB,OAAO,CAAC,yBAAyB;YAanB,IAAI;IAelB,OAAO,CAAC,eAAe;YAIT,YAAY;YA6BZ,wBAAwB;IAuBhC,IAAI,CAAC,YAAY,SAAS,YAAY,EAAE,GAAG,EAAE,SAAS;IAStD,YAAY,CAAC,OAAO,EAAE,gBAAgB,CAAC,YAAY,CAAC,EAAE;IAQtD,cAAc,CAAC,YAAY,SAAS,YAAY,EAClD,MAAM,EAAE,gBAAgB,CAAC,YAAY,CAAC,EACtC,MAAM,EAAE,MAAM;IAsBZ,yBAAyB,CAAC,YAAY,SAAS,YAAY,EAC7D,MAAM,EAAE,gBAAgB,CAAC,YAAY,CAAC,EACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,YAAY;IAcjB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,cAAc,CAAC,YAAY,SAAS,YAAY,EAClD,MAAM,EAAE,gBAAgB,CAAC,YAAY,CAAC,EACtC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;CAkB5D"}