chz-telegram-bot 0.5.2 → 0.5.3

package/dist/main.js

@@ -1,34 +0,0 @@
-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,
-                logger: options.services?.logger,
-                scheduler: options.services?.scheduler
-            },
-            storagePath: options.storagePath
-        });
-        await bot.start(token, options.actions, options.scheduledPeriod, options.verboseLoggingForIncomingMessage);
-        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

@@ -1,25 +0,0 @@
-import { Seconds } from '../types/timeValues';
-import { ILogger } from '../types/logger';
-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';
-export declare class ActionProcessingService {
-    private readonly storage;
-    private readonly logger;
-    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, logger: ILogger);
-    initialize(token: string, actions: {
-        commands: CommandAction<IActionState>[];
-        scheduled: ScheduledAction<IActionState>[];
-        inlineQueries: InlineQueryAction[];
-    }, scheduledPeriod?: Seconds, verboseLoggingForIncomingMessage?: boolean): Promise<void>;
-    stop(): void;
-}
-//# sourceMappingURL=actionProcessingService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"actionProcessingService.d.ts","sourceRoot":"","sources":["../../services/actionProcessingService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAuB,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,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;AAQtE,qBAAa,uBAAuB;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IAEjC,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,MAAM,EAAE,OAAO;IA4Bb,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,EACzB,gCAAgC,CAAC,EAAE,OAAO;IA2D9C,IAAI;CAGP"}

package/dist/services/actionProcessingService.js

@@ -1,50 +0,0 @@
-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 {
-    storage;
-    logger;
-    commandProcessor;
-    scheduledProcessor;
-    inlineQueryProcessor;
-    botName;
-    telegramBot;
-    constructor(botName, chats, storage, scheduler, logger) {
-        this.storage = storage;
-        this.logger = logger;
-        this.commandProcessor = new CommandActionProcessor(botName, storage, scheduler, logger);
-        this.scheduledProcessor = new ScheduledActionProcessor(botName, chats, storage, scheduler, logger);
-        this.inlineQueryProcessor = new InlineQueryActionProcessor(botName, storage, scheduler, logger);
-        this.botName = botName;
-    }
-    async initialize(token, actions, scheduledPeriod, verboseLoggingForIncomingMessage) {
-        this.telegramBot = new Telegraf(token);
-        const api = new TelegramApiService(this.botName, this.telegramBot.telegram, this.storage, this.logger, (capture, id, chatInfo, traceId) => {
-            this.commandProcessor.captureRegistrationCallback(capture, id, chatInfo, traceId);
-        });
-        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, verboseLoggingForIncomingMessage ?? false, 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

@@ -1,18 +0,0 @@
-import { ILogger } from '../../types/logger';
-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';
-export declare abstract class BaseActionProcessor {
-    protected readonly storage: IStorageClient;
-    protected readonly scheduler: IScheduler;
-    protected readonly logger: ILogger;
-    protected readonly botName: string;
-    protected api: TelegramApiService;
-    constructor(botName: string, storage: IStorageClient, scheduler: IScheduler, logger: ILogger);
-    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

@@ -1 +0,0 @@
-{"version":3,"file":"baseProcessor.d.ts","sourceRoot":"","sources":["../../../services/actionProcessors/baseProcessor.ts"],"names":[],"mappings":"AAAA,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,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAEzE,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,MAAM,EAAE,OAAO,CAAC;IAEnC,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,MAAM,EAAE,OAAO;IASnB,OAAO,CAAC,mBAAmB;IAO3B,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;CAUjE"}

package/dist/services/actionProcessors/baseProcessor.js

@@ -1,29 +0,0 @@
-export class BaseActionProcessor {
-    storage;
-    scheduler;
-    logger;
-    botName;
-    api;
-    constructor(botName, storage, scheduler, logger) {
-        this.storage = storage;
-        this.scheduler = scheduler;
-        this.logger = logger;
-        this.botName = botName;
-    }
-    defaultErrorHandler(error, ctx) {
-        ctx.logger.errorWithTraceId(error, ctx);
-    }
-    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);
-        }
-    }
-}

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

@@ -1,20 +0,0 @@
-import { CommandAction } from '../../entities/actions/commandAction';
-import { IActionState } from '../../types/actionState';
-import { TelegramApiService } from '../telegramApi';
-import { IReplyCapture } from '../../types/capture';
-import { TraceId } from '../../types/trace';
-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>[], verboseLoggingForIncomingMessage: boolean, botInfo: BotInfo): void;
-    captureRegistrationCallback(capture: IReplyCapture, parentMessageId: number, chatInfo: ChatInfo, traceId: TraceId): void;
-    private processMessage;
-    private initializeReplyCaptureContext;
-    private initializeMessageContext;
-}
-//# sourceMappingURL=commandActionProcessor.d.ts.map

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

@@ -1 +0,0 @@
-{"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,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,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;AAInE,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,gCAAgC,EAAE,OAAO,EACzC,OAAO,EAAE,OAAO;IA0DpB,2BAA2B,CACvB,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,OAAO;YAgCN,cAAc;IAoD5B,OAAO,CAAC,6BAA6B;IAiCrC,OAAO,CAAC,wBAAwB;CAmCnC"}

package/dist/services/actionProcessors/commandActionProcessor.js

@@ -1,116 +0,0 @@
-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));
-        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

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,61 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,56 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,109 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}