chz-telegram-bot 0.5.4 → 0.5.5

package/dist/services/actionProcessors/commandActionProcessor.js

@@ -0,0 +1,116 @@
+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';
+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, verboseLoggingForIncomingMessage, 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', ({ message }) => {
+                const internalMessage = new IncomingMessage(message, this.botName, getOrSetIfNotExists(this.chatHistory, message.chat.id, []));
+                const logger = this.logger.createScope(this.botName, internalMessage.traceId, internalMessage.chatInfo.name);
+                if (verboseLoggingForIncomingMessage) {
+                    logger.logObjectWithTraceId(message);
+                }
+                else {
+                    logger.logWithTraceId(`${internalMessage.from?.first_name ?? 'Unknown'} (${internalMessage.from?.id ?? 'Unknown'}): ${internalMessage.text || internalMessage.type}`);
+                }
+                void this.processMessage(internalMessage);
+            });
+        }
+    }
+    captureRegistrationCallback(capture, parentMessageId, chatInfo, traceId) {
+        const replyAction = new ReplyCaptureAction(parentMessageId, capture.action, capture.handler, capture.trigger, capture.abortController);
+        const logger = this.logger.createScope(this.botName, traceId, chatInfo.name);
+        logger.logWithTraceId(`Starting capturing replies to message ${parentMessageId} with action ${replyAction.key}`);
+        this.replyCaptures.push(replyAction);
+        capture.abortController.signal.addEventListener('abort', () => {
+            const index = this.replyCaptures.indexOf(replyAction);
+            this.replyCaptures.splice(index, 1);
+            logger.logWithTraceId(`Stopping capturing replies to message ${parentMessageId} with action ${replyAction.key}`);
+        });
+    }
+    async processMessage(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);
+        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);
+            }
+        }
+        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);
+            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 = [];
+        ctx.logger = this.logger.createScope(this.botName, message.traceId, message.chatInfo.name);
+    }
+    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;
+        ctx.logger = this.logger.createScope(this.botName, message.traceId, message.chatInfo.name);
+    }
+}

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;AAG7E,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;IAuGxB,OAAO,CAAC,4BAA4B;CAqBvC"}

package/dist/services/actionProcessors/inlineQueryActionProcessor.js

@@ -0,0 +1,61 @@
+import { IncomingInlineQuery } from '../../dtos/incomingQuery';
+import { InlineQueryContextInternal } from '../../entities/context/inlineQueryContext';
+import { createTrace } from '../../helpers/traceFactory';
+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));
+                const logger = this.logger.createScope(this.botName, query.traceId, 'Query');
+                logger.logWithTraceId(`${inlineQuery.from.username ?? 'Unknown'} (${inlineQuery.from.id}): Query for ${inlineQuery.query}`);
+                const queryBeingProcessed = queriesInProcessing.get(query.userId);
+                if (queryBeingProcessed) {
+                    logger.logWithTraceId(`Aborting query ${queryBeingProcessed.queryId} (${queryBeingProcessed.query}): new query recieved from ${query.userId}`);
+                    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);
+                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, 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);
+                }
+                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 = [];
+        ctx.logger = this.logger.createScope(this.botName, traceId, 'Unknown');
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ScheduledAction } from '../../entities/actions/scheduledAction';
+import { IActionState } from '../../types/actionState';
+import { ILogger } from '../../types/logger';
+import { IScheduler } from '../../types/scheduler';
+import { IStorageClient } from '../../types/storage';
+import { Seconds } from '../../types/timeValues';
+import { TelegramApiService } from '../telegramApi';
+import { BaseActionProcessor } from './baseProcessor';
+export declare class ScheduledActionProcessor extends BaseActionProcessor {
+    private readonly chats;
+    private scheduled;
+    constructor(botName: string, chats: Record<string, number>, storage: IStorageClient, scheduler: IScheduler, logger: ILogger);
+    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,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,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;AAEtD,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,MAAM,EAAE,OAAO;IAMnB,UAAU,CACN,GAAG,EAAE,kBAAkB,EACvB,SAAS,EAAE,eAAe,CAAC,YAAY,CAAC,EAAE,EAC1C,MAAM,EAAE,OAAO;YAgDL,YAAY;IA0B1B,OAAO,CAAC,qBAAqB;CAmBhC"}

package/dist/services/actionProcessors/scheduledActionProcessor.js

@@ -0,0 +1,56 @@
+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, logger) {
+        super(botName, storage, scheduler, logger);
+        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);
+        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;
+        ctx.logger = this.logger.createScope(this.botName, traceId, chatInfo.name);
+    }
+}

package/dist/services/jsonFileStorage.d.ts

@@ -0,0 +1,23 @@
+import { IStorageClient } from '../types/storage';
+import { IActionState } from '../types/actionState';
+import { IActionWithState, ActionKey } from '../types/action';
+export declare class JsonFileStorage implements IStorageClient {
+    private readonly filePaths;
+    private readonly locks;
+    private readonly cache;
+    private readonly storagePath;
+    private readonly botName;
+    constructor(botName: string, actions: IActionWithState<IActionState>[], 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;AAO9D,qBAAa,eAAgB,YAAW,cAAc;IAClD,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,IAAI,CAAC,EAAE,MAAM;IAqBjB,OAAO,CAAC,yBAAyB;YAanB,IAAI;IAYlB,OAAO,CAAC,eAAe;YAIT,YAAY;YA6BZ,wBAAwB;IAehC,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;IAWZ,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"}

package/dist/services/jsonFileStorage.js

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync } from 'fs';
+import { readFile, writeFile } from 'fs/promises';
+import { Sema as Semaphore } from 'async-sema';
+import { getOrSetIfNotExists } from '../helpers/mapUtils';
+function buildPath(storagePath, botName, actionKey) {
+    return `${storagePath}/${botName}/${actionKey.replaceAll(':', '/')}.json`;
+}
+export class JsonFileStorage {
+    filePaths = new Map();
+    locks = new Map();
+    cache;
+    storagePath;
+    botName;
+    constructor(botName, actions, path) {
+        this.cache = new Map();
+        this.botName = botName;
+        this.storagePath = path ?? 'storage';
+        if (!existsSync(`${this.storagePath}/${this.botName}/`)) {
+            mkdirSync(`${this.storagePath}/${this.botName}/`, {
+                recursive: true
+            });
+        }
+        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));
+        }
+    }
+    backfillEmptyActionStates(action, data) {
+        for (const [stringKey, value] of Object.entries(data)) {
+            if (value)
+                continue;
+            data[Number.parseInt(stringKey)] = action.stateConstructor();
+        }
+        return true;
+    }
+    async lock(key, action) {
+        const lock = getOrSetIfNotExists(this.locks, key, new Semaphore(1));
+        await lock.acquire();
+        try {
+            return await action();
+        }
+        finally {
+            lock.release();
+        }
+    }
+    tryGetFromCache(key) {
+        return this.cache.get(key);
+    }
+    async loadFromFile(key) {
+        const targetPath = getOrSetIfNotExists(this.filePaths, key, buildPath(this.storagePath, this.botName, key));
+        const fileContent = await readFile(targetPath, {
+            encoding: 'utf-8',
+            flag: 'a+'
+        });
+        if (fileContent) {
+            const data = JSON.parse(fileContent);
+            this.cache.set(key, data);
+        }
+        return (this.cache.get(key) ?? {});
+    }
+    async updateCacheAndSaveToFile(data, key) {
+        this.cache.set(key, data);
+        const targetPath = getOrSetIfNotExists(this.filePaths, key, buildPath(this.storagePath, this.botName, key));
+        await writeFile(targetPath, JSON.stringify(data), { flag: 'w+' });
+    }
+    async load(key) {
+        return (this.tryGetFromCache(key) ??
+            (await this.lock(key, async () => {
+                return await this.loadFromFile(key);
+            })));
+    }
+    async saveMetadata(actions) {
+        const targetPath = `${this.storagePath}/${this.botName}/Metadata-${this.botName}.json`;
+        await writeFile(targetPath, JSON.stringify(actions), {
+            flag: 'w+'
+        });
+    }
+    async getActionState(action, chatId) {
+        const value = this.tryGetFromCache(action.key) ??
+            (await this.lock(action.key, async () => {
+                return await this.loadFromFile(action.key);
+            }));
+        return Object.assign(action.stateConstructor(), value[chatId]);
+    }
+    async saveActionExecutionResult(action, chatId, state) {
+        await this.lock(action.key, async () => {
+            const data = this.tryGetFromCache(action.key) ??
+                (await this.loadFromFile(action.key));
+            data[chatId] = state;
+            if (this.backfillEmptyActionStates(action, data))
+                await this.updateCacheAndSaveToFile(data, action.key);
+        });
+    }
+    async close() {
+        for (const lock of this.locks.values()) {
+            await lock.acquire();
+        }
+    }
+    async updateStateFor(action, chatId, update) {
+        await this.lock(action.key, async () => {
+            const data = this.tryGetFromCache(action.key) ??
+                (await this.loadFromFile(action.key));
+            const state = Object.assign(action.stateConstructor(), data[chatId]);
+            await update(state);
+            if (this.backfillEmptyActionStates(action, data))
+                await this.updateCacheAndSaveToFile(data, action.key);
+        });
+    }
+}

package/dist/services/jsonLogger.d.ts

@@ -0,0 +1,11 @@
+import { ILogger, IScopedLogger } from '../types/logger';
+import { TraceId } from '../types/trace';
+export declare class JsonLogger implements ILogger {
+    private serializeError;
+    private getCircularReplacer;
+    createScope(botName: string, traceId: TraceId, chatName: string): IScopedLogger;
+    logObjectWithTraceId(botName: string, traceId: TraceId, chatName: string, data: unknown): void;
+    logWithTraceId(botName: string, traceId: TraceId, chatName: string, text: string): void;
+    errorWithTraceId(botName: string, traceId: TraceId, chatName: string, errorObj: unknown, extraData?: unknown): void;
+}
+//# sourceMappingURL=jsonLogger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsonLogger.d.ts","sourceRoot":"","sources":["../../services/jsonLogger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzC,qBAAa,UAAW,YAAW,OAAO;IACtC,OAAO,CAAC,cAAc;IAkBtB,OAAO,CAAC,mBAAmB;IAc3B,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAiBtD,aAAa;IAGtB,oBAAoB,CAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO;IAoBjB,cAAc,CACV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM;IAOhB,gBAAgB,CACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,EACjB,SAAS,CAAC,EAAE,OAAO;CAe1B"}

package/dist/services/jsonLogger.js

@@ -0,0 +1,66 @@
+export class JsonLogger {
+    serializeError(error) {
+        if (error instanceof Error) {
+            const plainObject = {
+                name: error.name,
+                message: error.message,
+                stack: error.stack
+            };
+            for (const [key, value] of Object.entries(error)) {
+                plainObject[key] = value;
+            }
+            return JSON.stringify(plainObject);
+        }
+        return JSON.stringify({ error });
+    }
+    getCircularReplacer() {
+        const cache = new Set();
+        return (_, value) => {
+            if (typeof value === 'object' && value !== null) {
+                if (cache.has(value)) {
+                    return;
+                }
+                cache.add(value);
+            }
+            return value;
+        };
+    }
+    createScope(botName, traceId, chatName) {
+        return {
+            logObjectWithTraceId: (data) => {
+                this.logObjectWithTraceId(botName, traceId, chatName, data);
+            },
+            logWithTraceId: (text) => {
+                this.logWithTraceId(botName, traceId, chatName, text);
+            },
+            errorWithTraceId: (errorObj, extraData) => {
+                this.errorWithTraceId(botName, traceId, chatName, errorObj, extraData);
+            }
+        };
+    }
+    logObjectWithTraceId(botName, traceId, chatName, data) {
+        const enrichedData = typeof data == 'object'
+            ? {
+                ...data,
+                botName,
+                traceId,
+                chatName
+            }
+            : {
+                botName,
+                traceId,
+                chatName,
+                data
+            };
+        console.log(enrichedData);
+    }
+    logWithTraceId(botName, traceId, chatName, text) {
+        console.log(`{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","text":"${text}"}`);
+    }
+    errorWithTraceId(botName, traceId, chatName, errorObj, extraData) {
+        const dataString = extraData
+            ? `,"extraData":${JSON.stringify(extraData, this.getCircularReplacer())}`
+            : '';
+        console.error(`{"botName":"${botName}","traceId":"${traceId}","chatName":"${chatName}","error":${this.serializeError(errorObj)}${dataString}}`);
+    }
+}

package/dist/services/nodeTimeoutScheduler.d.ts

@@ -0,0 +1,13 @@
+import { TaskRecord } from '../entities/taskRecord';
+import { ILogger } from '../types/logger';
+import { IScheduler } from '../types/scheduler';
+import { Milliseconds } from '../types/timeValues';
+export declare class NodeTimeoutScheduler implements IScheduler {
+    private readonly logger;
+    readonly activeTasks: TaskRecord[];
+    constructor(logger: ILogger);
+    stopAll(): void;
+    createTask(name: string, action: () => unknown, interval: Milliseconds, executeRightAway: boolean, ownerName: string): void;
+    createOnetimeTask(name: string, action: () => unknown, delay: Milliseconds, ownerName: string): void;
+}
+//# sourceMappingURL=nodeTimeoutScheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeTimeoutScheduler.d.ts","sourceRoot":"","sources":["../../services/nodeTimeoutScheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,qBAAa,oBAAqB,YAAW,UAAU;IACnD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,CAAM;gBAE5B,MAAM,EAAE,OAAO;IAI3B,OAAO;IAMP,UAAU,CACN,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,OAAO,EACrB,QAAQ,EAAE,YAAY,EACtB,gBAAgB,EAAE,OAAO,EACzB,SAAS,EAAE,MAAM;IAmBrB,iBAAiB,CACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,OAAO,EACrB,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM;CAoBxB"}

package/dist/services/nodeTimeoutScheduler.js

@@ -0,0 +1,31 @@
+import { TaskRecord } from '../entities/taskRecord';
+import { createTrace } from '../helpers/traceFactory';
+export class NodeTimeoutScheduler {
+    logger;
+    activeTasks = [];
+    constructor(logger) {
+        this.logger = logger;
+    }
+    stopAll() {
+        for (const task of this.activeTasks) {
+            clearInterval(task.taskId);
+        }
+    }
+    createTask(name, action, interval, executeRightAway, ownerName) {
+        const taskId = setInterval(action, interval);
+        const task = new TaskRecord(name, taskId, interval);
+        if (executeRightAway) {
+            setImmediate(action);
+        }
+        this.logger.logWithTraceId(ownerName, createTrace(this, ownerName, name), 'System', `Created task ${name}, that will run every ${interval}ms.`);
+        this.activeTasks.push(task);
+    }
+    createOnetimeTask(name, action, delay, ownerName) {
+        const actionWrapper = () => {
+            this.logger.logWithTraceId(ownerName, createTrace(this, ownerName, name), 'System', `Executing delayed oneshot ${name}`);
+            action();
+        };
+        setTimeout(actionWrapper, delay);
+        this.logger.logWithTraceId(ownerName, createTrace(this, ownerName, name), 'System', `Created oneshot task ${name}, that will run in ${delay}ms.`);
+    }
+}

package/dist/services/responseProcessingQueue.d.ts

@@ -0,0 +1,12 @@
+export type QueueItem = {
+    priority: number;
+    callback: () => Promise<void>;
+};
+export declare class ResponseProcessingQueue {
+    rateLimiter: () => Promise<void>;
+    items: QueueItem[];
+    isFlushing: boolean;
+    enqueue(item: QueueItem): void;
+    flushReadyItems(): Promise<void>;
+}
+//# sourceMappingURL=responseProcessingQueue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"responseProcessingQueue.d.ts","sourceRoot":"","sources":["../../services/responseProcessingQueue.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,SAAS,GAAG;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC,CAAC;AAQF,qBAAa,uBAAuB;IAChC,WAAW,sBAAwD;IACnE,KAAK,EAAE,SAAS,EAAE,CAAM;IACxB,UAAU,UAAS;IAEnB,OAAO,CAAC,IAAI,EAAE,SAAS;IAmBjB,eAAe;CAkBxB"}

package/dist/services/responseProcessingQueue.js

@@ -0,0 +1,37 @@
+import { RateLimit } from 'async-sema';
+function notEmpty(arr) {
+    return arr.length > 0;
+}
+const TELEGRAM_RATELIMIT_DELAY = 35;
+export class ResponseProcessingQueue {
+    rateLimiter = RateLimit(1, { timeUnit: TELEGRAM_RATELIMIT_DELAY });
+    items = [];
+    isFlushing = false;
+    enqueue(item) {
+        if (this.items.length === 0 ||
+            item.priority >= this.items[this.items.length - 1].priority) {
+            this.items.push(item);
+            return;
+        }
+        let insertIndex = this.items.length;
+        while (insertIndex > 0 &&
+            this.items[insertIndex - 1].priority > item.priority) {
+            insertIndex--;
+        }
+        this.items.splice(insertIndex, 0, item);
+    }
+    async flushReadyItems() {
+        if (this.isFlushing)
+            return;
+        this.isFlushing = true;
+        while (notEmpty(this.items)) {
+            if (Date.now() >= this.items[0].priority) {
+                await this.rateLimiter();
+                const [item] = this.items;
+                this.items.shift();
+                await item.callback();
+            }
+        }
+        this.isFlushing = false;
+    }
+}

package/dist/services/telegramApi.d.ts

@@ -0,0 +1,23 @@
+import { IStorageClient } from '../types/storage';
+import { BotResponse } from '../types/response';
+import { ILogger } from '../types/logger';
+import { IReplyCapture } from '../types/capture';
+import { TraceId } from '../types/trace';
+import { ChatInfo } from '../dtos/chatInfo';
+import { TelegramApiClient } from '../types/externalAliases';
+export declare const TELEGRAM_ERROR_QUOTE_INVALID = "QUOTE_TEXT_INVALID";
+export declare class TelegramApiService {
+    private readonly queue;
+    private readonly telegram;
+    private readonly storage;
+    private readonly logger;
+    private readonly captureRegistrationCallback;
+    private readonly botName;
+    constructor(botName: string, telegram: TelegramApiClient, storage: IStorageClient, logger: ILogger, captureRegistrationCallback: (capture: IReplyCapture, parentMessageId: number, chatInfo: ChatInfo, traceId: TraceId) => void);
+    enqueueBatchedResponses(responses: BotResponse[]): void;
+    flushResponses(): void;
+    private pinIfShould;
+    private processResponse;
+    private sendApiRequest;
+}
+//# sourceMappingURL=telegramApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"telegramApi.d.ts","sourceRoot":"","sources":["../../services/telegramApi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAmB,MAAM,0BAA0B,CAAC;AAE9E,eAAO,MAAM,4BAA4B,uBAAuB,CAAC;AAEjE,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;IACvD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAKlC;IAEV,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAG7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,OAAO,EACf,2BAA2B,EAAE,CACzB,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,OAAO,KACf,IAAI;IASb,uBAAuB,CAAC,SAAS,EAAE,WAAW,EAAE;IAwDhD,cAAc;YAIA,WAAW;YAqBX,eAAe;YAiBf,cAAc;CA6F/B"}