chz-telegram-bot 0.0.45 → 0.0.47

package/dist/entities/actionExecutionResult.d.ts

@@ -0,0 +1,7 @@
+import { IActionState } from '../types/actionState';
+export declare class ActionExecutionResult<TActionState extends IActionState> {
+    data: TActionState;
+    shouldUpdate: boolean;
+    constructor(data: TActionState, shouldUpdate: boolean);
+}
+//# sourceMappingURL=actionExecutionResult.d.ts.map

package/dist/entities/actionExecutionResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionExecutionResult.d.ts","sourceRoot":"","sources":["../../entities/actionExecutionResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,qBAAa,qBAAqB,CAAC,YAAY,SAAS,YAAY;IAChE,IAAI,EAAE,YAAY,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;gBAEV,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO;CAIxD"}

package/dist/entities/actionExecutionResult.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionExecutionResult = void 0;
+class ActionExecutionResult {
+    constructor(data, shouldUpdate) {
+        this.data = data;
+        this.shouldUpdate = shouldUpdate;
+    }
+}
+exports.ActionExecutionResult = ActionExecutionResult;

package/dist/entities/actions/commandAction.d.ts

@@ -0,0 +1,23 @@
+import { CommandHandler } from '../../types/handlers';
+import { CommandCondition } from '../../types/commandCondition';
+import { Seconds } from '../../types/timeValues';
+import { IActionState } from '../../types/actionState';
+import { IActionWithState, ActionKey } from '../../types/actionWithState';
+import { MessageContext } from '../context/messageContext';
+import { CommandTrigger } from '../../types/commandTrigger';
+export declare class CommandAction<TActionState extends IActionState> implements IActionWithState<TActionState> {
+    triggers: CommandTrigger[];
+    handler: CommandHandler<TActionState>;
+    name: string;
+    cooldownInSeconds: Seconds;
+    active: boolean;
+    chatsBlacklist: number[];
+    allowedUsers: number[];
+    condition: CommandCondition<TActionState>;
+    stateConstructor: () => TActionState;
+    key: ActionKey;
+    constructor(trigger: CommandTrigger | CommandTrigger[], handler: CommandHandler<TActionState>, name: string, active: boolean, cooldown: Seconds, chatsBlacklist: number[], allowedUsers: number[], condition: CommandCondition<TActionState>, stateConstructor: () => TActionState);
+    exec(ctx: MessageContext<TActionState>): Promise<void>;
+    private checkTrigger;
+}
+//# sourceMappingURL=commandAction.d.ts.map

package/dist/entities/actions/commandAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandAction.d.ts","sourceRoot":"","sources":["../../../entities/actions/commandAction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGjD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE1E,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAG3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,qBAAa,aAAa,CAAC,YAAY,SAAS,YAAY,CACxD,YAAW,gBAAgB,CAAC,YAAY,CAAC;IAEzC,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,OAAO,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,OAAO,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAC1C,gBAAgB,EAAE,MAAM,YAAY,CAAC;IACrC,GAAG,EAAE,SAAS,CAAC;gBAGX,OAAO,EAAE,cAAc,GAAG,cAAc,EAAE,EAC1C,OAAO,EAAE,cAAc,CAAC,YAAY,CAAC,EACrC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,OAAO,EACjB,cAAc,EAAE,MAAM,EAAE,EACxB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,gBAAgB,CAAC,YAAY,CAAC,EACzC,gBAAgB,EAAE,MAAM,YAAY;IAelC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,YAAY,CAAC;IAkD5C,OAAO,CAAC,YAAY;CAwDvB"}

package/dist/entities/actions/commandAction.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandAction = void 0;
+const moment_1 = __importDefault(require("moment"));
+const timeConvertions_1 = require("../../helpers/timeConvertions");
+const toArray_1 = require("../../helpers/toArray");
+const commandTriggerCheckResult_1 = require("../commandTriggerCheckResult");
+const logger_1 = require("../../services/logger");
+const actionExecutionResult_1 = require("../actionExecutionResult");
+class CommandAction {
+    constructor(trigger, handler, name, active, cooldown, chatsBlacklist, allowedUsers, condition, stateConstructor) {
+        this.triggers = (0, toArray_1.toArray)(trigger);
+        this.handler = handler;
+        this.name = name;
+        this.cooldownInSeconds = cooldown;
+        this.active = active;
+        this.chatsBlacklist = chatsBlacklist;
+        this.allowedUsers = allowedUsers;
+        this.condition = condition;
+        this.stateConstructor = stateConstructor;
+        this.key = `command:${this.name.replace('.', '-')}`;
+    }
+    async exec(ctx) {
+        if (!ctx.isInitialized)
+            throw new Error('Context is not initialized');
+        if (!this.active || this.chatsBlacklist.includes(ctx.chatId))
+            return;
+        const isConditionMet = await this.condition(ctx);
+        if (!isConditionMet)
+            return;
+        const state = await ctx.storage.getActionState(this, ctx.chatId);
+        const { shouldTrigger, matchResults, skipCooldown } = this.triggers
+            .map((x) => this.checkTrigger(ctx, x, state))
+            .reduce((acc, curr) => acc.mergeWith(curr), commandTriggerCheckResult_1.CommandTriggerCheckResult.DoNotTrigger);
+        if (!shouldTrigger)
+            return;
+        logger_1.Logger.logWithTraceId(ctx.botName, ctx.traceId, ctx.chatName, ` - Executing [${this.name}] in ${ctx.chatId}`);
+        ctx.matchResults = matchResults;
+        await this.handler(ctx, state);
+        if (skipCooldown) {
+            ctx.startCooldown = false;
+        }
+        if (ctx.startCooldown) {
+            state.lastExecutedDate = (0, moment_1.default)().valueOf();
+        }
+        ctx.updateActions.forEach((action) => action(state));
+        await ctx.storage.saveActionExecutionResult(this, ctx.chatId, new actionExecutionResult_1.ActionExecutionResult(state, ctx.startCooldown && shouldTrigger));
+    }
+    checkTrigger(ctx, trigger, state) {
+        let shouldTrigger = false;
+        const matchResults = [];
+        if (!ctx.fromUserId)
+            return commandTriggerCheckResult_1.CommandTriggerCheckResult.DontTriggerAndSkipCooldown;
+        const isUserAllowed = this.allowedUsers.length == 0 ||
+            this.allowedUsers.includes(ctx.fromUserId);
+        if (!isUserAllowed)
+            return commandTriggerCheckResult_1.CommandTriggerCheckResult.DontTriggerAndSkipCooldown;
+        const lastExecutedDate = (0, moment_1.default)(state.lastExecutedDate);
+        const cooldownInMilliseconds = (0, timeConvertions_1.secondsToMilliseconds)(this.cooldownInSeconds);
+        const onCooldown = (0, moment_1.default)().diff(lastExecutedDate) < cooldownInMilliseconds;
+        if (onCooldown)
+            return commandTriggerCheckResult_1.CommandTriggerCheckResult.DoNotTrigger;
+        if (trigger == ctx.messageType) {
+            shouldTrigger = true;
+        }
+        else if (typeof trigger == 'string') {
+            shouldTrigger = ctx.messageText.toLowerCase() == trigger;
+        }
+        else {
+            trigger.lastIndex = 0;
+            const execResult = trigger.exec(ctx.messageText);
+            if (execResult != null) {
+                matchResults.push(execResult);
+                if (trigger.global) {
+                    while (true) {
+                        const nextResult = trigger.exec(ctx.messageText);
+                        if (nextResult == null)
+                            break;
+                        matchResults.push(nextResult);
+                    }
+                }
+            }
+            shouldTrigger = matchResults.length > 0;
+        }
+        return new commandTriggerCheckResult_1.CommandTriggerCheckResult(shouldTrigger, matchResults, false);
+    }
+}
+exports.CommandAction = CommandAction;

package/dist/entities/actions/scheduledAction.d.ts

@@ -0,0 +1,24 @@
+import { Sema as Semaphore } from 'async-sema';
+import { ScheduledHandler } from '../../types/handlers';
+import { HoursOfDay } from '../../types/timeValues';
+import { IActionState } from '../../types/actionState';
+import { IActionWithState, ActionKey } from '../../types/actionWithState';
+import { CachedStateFactory } from '../cachedStateFactory';
+import { ChatContext } from '../context/chatContext';
+export declare class ScheduledAction<TActionState extends IActionState> implements IActionWithState<TActionState> {
+    static locks: Map<string, Semaphore>;
+    name: string;
+    timeinHours: HoursOfDay;
+    active: boolean;
+    chatsWhitelist: number[];
+    key: ActionKey;
+    cachedState: Map<string, unknown>;
+    stateConstructor: () => TActionState;
+    cachedStateFactories: Map<string, CachedStateFactory>;
+    handler: ScheduledHandler<TActionState>;
+    constructor(name: string, handler: ScheduledHandler<TActionState>, timeinHours: HoursOfDay, active: boolean, whitelist: number[], cachedStateFactories: Map<string, CachedStateFactory>, stateConstructor: () => TActionState);
+    exec(ctx: ChatContext<TActionState>): Promise<void>;
+    private getCachedValue;
+    private shouldTrigger;
+}
+//# sourceMappingURL=scheduledAction.d.ts.map

package/dist/entities/actions/scheduledAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduledAction.d.ts","sourceRoot":"","sources":["../../../entities/actions/scheduledAction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAKrD,qBAAa,eAAe,CAAC,YAAY,SAAS,YAAY,CAC1D,YAAW,gBAAgB,CAAC,YAAY,CAAC;IAEzC,MAAM,CAAC,KAAK,yBAAgC;IAE5C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,UAAU,CAAC;IACxB,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,GAAG,EAAE,SAAS,CAAC;IAEf,WAAW,uBAA8B;IACzC,gBAAgB,EAAE,MAAM,YAAY,CAAC;IACrC,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IACtD,OAAO,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;gBAGpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,gBAAgB,CAAC,YAAY,CAAC,EACvC,WAAW,EAAE,UAAU,EACvB,MAAM,EAAE,OAAO,EACf,SAAS,EAAE,MAAM,EAAE,EACnB,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EACrD,gBAAgB,EAAE,MAAM,YAAY;IAYlC,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC,YAAY,CAAC;YAqC3B,cAAc;IA8C5B,OAAO,CAAC,aAAa;CAaxB"}

package/dist/entities/actions/scheduledAction.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduledAction = void 0;
+const moment_1 = __importDefault(require("moment"));
+const async_sema_1 = require("async-sema");
+const timeConvertions_1 = require("../../helpers/timeConvertions");
+const actionExecutionResult_1 = require("../actionExecutionResult");
+const logger_1 = require("../../services/logger");
+const taskScheduler_1 = require("../../services/taskScheduler");
+class ScheduledAction {
+    constructor(name, handler, timeinHours, active, whitelist, cachedStateFactories, stateConstructor) {
+        this.cachedState = new Map();
+        this.name = name;
+        this.handler = handler;
+        this.timeinHours = timeinHours;
+        this.active = active;
+        this.chatsWhitelist = whitelist;
+        this.cachedStateFactories = cachedStateFactories;
+        this.key = `scheduled:${this.name.replace('.', '-')}`;
+        this.stateConstructor = stateConstructor;
+    }
+    async exec(ctx) {
+        if (!ctx.isInitialized)
+            throw new Error('Context is not initialized');
+        if (!this.active || !this.chatsWhitelist.includes(ctx.chatId))
+            return;
+        const state = await ctx.storage.getActionState(this, ctx.chatId);
+        const isAllowedToTrigger = this.shouldTrigger(state);
+        if (isAllowedToTrigger) {
+            logger_1.Logger.logWithTraceId(ctx.botName, ctx.traceId, ctx.chatName, ` - Executing [${this.name}] in ${ctx.chatId}`);
+            await this.handler(ctx, (key) => this.getCachedValue(key, ctx.botName), state);
+            state.lastExecutedDate = (0, moment_1.default)().valueOf();
+            ctx.updateActions.forEach((action) => action(state));
+            await ctx.storage.saveActionExecutionResult(this, ctx.chatId, new actionExecutionResult_1.ActionExecutionResult(state, isAllowedToTrigger));
+        }
+    }
+    async getCachedValue(key, botName) {
+        if (!this.cachedStateFactories.has(key)) {
+            throw new Error(`No shared cache was set up for the key [${key}] in action '${this.name}'`);
+        }
+        const semaphoreKey = `${this.key}_cached:${key}`;
+        let semaphore;
+        if (ScheduledAction.locks.has(semaphoreKey)) {
+            semaphore = ScheduledAction.locks.get(semaphoreKey);
+        }
+        else {
+            semaphore = new async_sema_1.Sema(1);
+            ScheduledAction.locks.set(semaphoreKey, semaphore);
+        }
+        await semaphore.acquire();
+        try {
+            if (this.cachedState.has(key)) {
+                return this.cachedState.get(key);
+            }
+            const cachedItemFactory = this.cachedStateFactories.get(key);
+            const value = await cachedItemFactory.getValue();
+            this.cachedState.set(key, value);
+            taskScheduler_1.Scheduler.createOnetimeTask(`Drop cached value [${this.name} : ${key}]`, () => this.cachedState.delete(key), (0, timeConvertions_1.hoursToMilliseconds)(cachedItemFactory.invalidationTimeoutInHours), botName);
+            return value;
+        }
+        finally {
+            semaphore.release();
+        }
+    }
+    shouldTrigger(state) {
+        const startOfToday = (0, moment_1.default)().startOf('day').valueOf();
+        const lastExecutedDate = (0, moment_1.default)(state.lastExecutedDate);
+        const currentTime = (0, moment_1.default)();
+        const scheduledTime = (0, moment_1.default)()
+            .startOf('day')
+            .add(this.timeinHours, 'hours');
+        const isAllowedToTrigger = currentTime.isSameOrAfter(scheduledTime);
+        const hasTriggeredToday = lastExecutedDate.isAfter(startOfToday);
+        return isAllowedToTrigger && !hasTriggeredToday;
+    }
+}
+exports.ScheduledAction = ScheduledAction;
+ScheduledAction.locks = new Map();

package/dist/entities/botInstance.d.ts

@@ -0,0 +1,31 @@
+import { Seconds } from '../types/timeValues';
+import { IStorageClient } from '../types/storage';
+import { IActionState } from '../types/actionState';
+import { CommandAction } from './actions/commandAction';
+import { ScheduledAction } from './actions/scheduledAction';
+export declare class BotInstance {
+    name: string;
+    private api;
+    private telegraf;
+    private commands;
+    private scheduled;
+    private chats;
+    storage: IStorageClient;
+    constructor(options: {
+        name: string;
+        token: string;
+        commands: CommandAction<IActionState>[];
+        scheduled: ScheduledAction<IActionState>[];
+        chats: Record<string, number>;
+        storageClient?: IStorageClient;
+        storagePath?: string;
+        scheduledPeriod?: Seconds;
+        verboseLoggingForIncomingMessage?: boolean;
+    });
+    private initializeScheduledProcessing;
+    private initializeMessageProcessing;
+    stop(code: string): Promise<void>;
+    private runScheduled;
+    private processMessage;
+}
+//# sourceMappingURL=botInstance.d.ts.map

package/dist/entities/botInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"botInstance.d.ts","sourceRoot":"","sources":["../../entities/botInstance.ts"],"names":[],"mappings":"AAKA,OAAO,EAAuB,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAQ5D,qBAAa,WAAW;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,GAAG,CAAqB;IAChC,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,EAAE,cAAc,CAAC;gBAEZ,OAAO,EAAE;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,EAAE,CAAC;QACxC,SAAS,EAAE,eAAe,CAAC,YAAY,CAAC,EAAE,CAAC;QAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC9B,aAAa,CAAC,EAAE,cAAc,CAAC;QAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,gCAAgC,CAAC,EAAE,OAAO,CAAC;KAC9C;IAqCD,OAAO,CAAC,6BAA6B;IA2CrC,OAAO,CAAC,2BAA2B;IAiC7B,IAAI,CAAC,IAAI,EAAE,MAAM;YAYT,YAAY;YAwBZ,cAAc;CAqB/B"}

package/dist/entities/botInstance.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotInstance = void 0;
+const telegraf_1 = require("telegraf");
+const timeConvertions_1 = require("../helpers/timeConvertions");
+const jsonFileStorage_1 = require("../services/jsonFileStorage");
+const telegramApi_1 = require("../services/telegramApi");
+const logger_1 = require("../services/logger");
+const taskScheduler_1 = require("../services/taskScheduler");
+const incomingMessage_1 = require("./incomingMessage");
+const moment_1 = __importDefault(require("moment"));
+const chatContext_1 = require("./context/chatContext");
+const messageContext_1 = require("./context/messageContext");
+class BotInstance {
+    constructor(options) {
+        this.name = options.name;
+        this.commands = options.commands;
+        this.scheduled = options.scheduled;
+        this.chats = options.chats;
+        const actions = [...this.commands, ...this.scheduled];
+        logger_1.Logger.logWithTraceId(this.name, `System:Bot-${this.name}-Start`, 'System', 'Starting bot...');
+        this.telegraf = new telegraf_1.Telegraf(options.token);
+        this.storage =
+            options.storageClient ??
+                new jsonFileStorage_1.JsonFileStorage(options.name, actions, options.storagePath);
+        this.api = new telegramApi_1.TelegramApiService(this.name, this.telegraf.telegram, this.storage, this.chats);
+        this.initializeMessageProcessing(options.verboseLoggingForIncomingMessage ?? false);
+        this.initializeScheduledProcessing(options.scheduledPeriod ?? (0, timeConvertions_1.hoursToSeconds)(1));
+        this.storage.saveMetadata(actions, this.name);
+        this.telegraf.launch();
+    }
+    initializeScheduledProcessing(period) {
+        if (this.scheduled.length > 0) {
+            const now = (0, moment_1.default)();
+            if (now.minute() == 0 && now.second() == 0) {
+                taskScheduler_1.Scheduler.createTask('ScheduledProcessing', async () => {
+                    await this.runScheduled();
+                }, (0, timeConvertions_1.secondsToMilliseconds)(period), true, this.name);
+                return;
+            }
+            let nextExecutionTime = now.clone().startOf('hour');
+            if (now.minute() > 0 || now.second() > 0) {
+                nextExecutionTime = nextExecutionTime.add(1, 'hour');
+            }
+            const delay = nextExecutionTime.diff(now);
+            taskScheduler_1.Scheduler.createOnetimeTask('ScheduledProcessing_OneTime', async () => {
+                taskScheduler_1.Scheduler.createTask('ScheduledProcessing', async () => {
+                    await this.runScheduled();
+                }, (0, timeConvertions_1.secondsToMilliseconds)(period), true, this.name);
+            }, delay, this.name);
+        }
+    }
+    initializeMessageProcessing(verboseLoggingForIncomingMessage) {
+        if (this.commands.length > 0) {
+            this.telegraf.on('message', async (ctx) => {
+                const msg = new incomingMessage_1.IncomingMessage(ctx.update.message);
+                const messageContent = msg.text || `<non-text message: ${msg.type}>`;
+                const messageFromName = msg.from?.first_name ?? 'Unknown';
+                const messageFromId = msg.from?.id ?? 'Unknown';
+                if (verboseLoggingForIncomingMessage) {
+                    logger_1.Logger.logObjectWithTraceId(this.name, msg.traceId, msg.chatName, ctx.update.message);
+                }
+                else {
+                    logger_1.Logger.logWithTraceId(this.name, msg.traceId, msg.chatName, `${messageFromName} (${messageFromId}): ${messageContent}`);
+                }
+                await this.processMessage(msg);
+            });
+        }
+    }
+    async stop(code) {
+        logger_1.Logger.logWithTraceId(this.name, `System:Bot-${this.name}-Stop`, 'System', 'Stopping bot...');
+        await this.storage.close();
+        this.telegraf.stop(code);
+    }
+    async runScheduled() {
+        const ctx = new chatContext_1.ChatContext();
+        for (const [chatName, chatId] of Object.entries(this.chats)) {
+            for (const scheduledAction of this.scheduled) {
+                this.api.initializeContextForChat(ctx, chatId, scheduledAction);
+                try {
+                    await scheduledAction.exec(ctx);
+                }
+                catch (error) {
+                    logger_1.Logger.errorWithTraceId(ctx.botName, ctx.traceId, chatName, error, ctx);
+                }
+            }
+        }
+        await this.api.flushResponses();
+    }
+    async processMessage(msg) {
+        const ctx = new messageContext_1.MessageContext();
+        for (const commandAction of this.commands) {
+            this.api.initializeContextForMessage(ctx, msg, commandAction);
+            try {
+                await commandAction.exec(ctx);
+            }
+            catch (error) {
+                logger_1.Logger.errorWithTraceId(ctx.botName, ctx.traceId, ctx.chatName, error, ctx);
+            }
+        }
+        await this.api.flushResponses();
+    }
+}
+exports.BotInstance = BotInstance;

package/dist/entities/cachedStateFactory.d.ts

@@ -0,0 +1,7 @@
+import { Hours } from '../types/timeValues';
+export declare class CachedStateFactory {
+    getValue: () => Promise<unknown>;
+    invalidationTimeoutInHours: Hours;
+    constructor(itemFactory: () => Promise<unknown>, invalidationTimeout: Hours);
+}
+//# sourceMappingURL=cachedStateFactory.d.ts.map

package/dist/entities/cachedStateFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachedStateFactory.d.ts","sourceRoot":"","sources":["../../entities/cachedStateFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,qBAAa,kBAAkB;IAC3B,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACjC,0BAA0B,EAAE,KAAK,CAAC;gBAG9B,WAAW,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EACnC,mBAAmB,EAAE,KAAK;CAKjC"}

package/dist/entities/cachedStateFactory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedStateFactory = void 0;
+class CachedStateFactory {
+    constructor(itemFactory, invalidationTimeout) {
+        this.getValue = itemFactory;
+        this.invalidationTimeoutInHours = invalidationTimeout;
+    }
+}
+exports.CachedStateFactory = CachedStateFactory;

package/dist/entities/commandTriggerCheckResult.d.ts

@@ -0,0 +1,10 @@
+export declare class CommandTriggerCheckResult {
+    static get DontTriggerAndSkipCooldown(): CommandTriggerCheckResult;
+    static get DoNotTrigger(): CommandTriggerCheckResult;
+    shouldTrigger: boolean;
+    matchResults: RegExpExecArray[];
+    skipCooldown: boolean;
+    constructor(shouldTrigger: boolean, matchResults: RegExpExecArray[], skipCooldown: boolean);
+    mergeWith(other: CommandTriggerCheckResult): this;
+}
+//# sourceMappingURL=commandTriggerCheckResult.d.ts.map

package/dist/entities/commandTriggerCheckResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandTriggerCheckResult.d.ts","sourceRoot":"","sources":["../../entities/commandTriggerCheckResult.ts"],"names":[],"mappings":"AAAA,qBAAa,yBAAyB;IAClC,MAAM,KAAK,0BAA0B,8BAEpC;IACD,MAAM,KAAK,YAAY,8BAEtB;IAED,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,YAAY,EAAE,OAAO,CAAC;gBAGlB,aAAa,EAAE,OAAO,EACtB,YAAY,EAAE,eAAe,EAAE,EAC/B,YAAY,EAAE,OAAO;IAOzB,SAAS,CAAC,KAAK,EAAE,yBAAyB;CAO7C"}

package/dist/entities/commandTriggerCheckResult.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandTriggerCheckResult = void 0;
+class CommandTriggerCheckResult {
+    static get DontTriggerAndSkipCooldown() {
+        return new CommandTriggerCheckResult(false, [], true);
+    }
+    static get DoNotTrigger() {
+        return new CommandTriggerCheckResult(false, [], false);
+    }
+    constructor(shouldTrigger, matchResults, skipCooldown) {
+        this.shouldTrigger = shouldTrigger;
+        this.matchResults = matchResults;
+        this.skipCooldown = skipCooldown;
+    }
+    mergeWith(other) {
+        this.shouldTrigger = this.shouldTrigger || other.shouldTrigger;
+        this.matchResults = this.matchResults.concat(other.matchResults);
+        this.skipCooldown = this.skipCooldown || other.skipCooldown;
+        return this;
+    }
+}
+exports.CommandTriggerCheckResult = CommandTriggerCheckResult;

package/dist/entities/context/chatContext.d.ts

@@ -0,0 +1,55 @@
+import { IBotApiInteractions } from '../../services/telegramApi';
+import { IStorageClient } from '../../types/storage';
+import { MessageSendingOptions, TextMessageSendingOptions } from '../../types/messageSendingOptions';
+import { IActionWithState } from '../../types/actionWithState';
+import { IActionState } from '../../types/actionState';
+/**
+ * Context of action executed in chat.
+ */
+export declare class ChatContext<TActionState extends IActionState> {
+    protected action: IActionWithState<TActionState>;
+    protected interactions: IBotApiInteractions;
+    updateActions: Array<(state: TActionState) => void>;
+    /** Trace id of a action execution. */
+    traceId: number | string;
+    /** Name of a bot that executes this action. */
+    botName: string;
+    /** Id of a chat that action is executed in. */
+    chatId: number;
+    /** Name of a chat that action is executed in. */
+    chatName: string;
+    /** Storage client instance for this bot. */
+    storage: IStorageClient;
+    isInitialized: boolean;
+    constructor();
+    initializeChatContext(botName: string, action: IActionWithState<TActionState>, interactions: IBotApiInteractions, chatId: number, chatName: string, traceId: number | string, storage: IStorageClient): this;
+    /**
+     * Manually update the state of an action.
+     * @param stateUpdateAction Function that will modify state.
+     */
+    updateState(stateUpdateAction: (state: TActionState) => void): void;
+    /**
+     * Sends text message to chat.
+     * @param text Message contents.
+     * @param options Message sending option.
+     */
+    sendTextToChat(text: string, options?: TextMessageSendingOptions): void;
+    /**
+     * Sends image message to chat.
+     * @param name Message contents.
+     * @param options Message sending option.
+     */
+    sendImageToChat(name: string, options?: MessageSendingOptions): void;
+    /**
+     * Sends video/gif message to chat.
+     * @param name Message contents.
+     * @param options Message sending option.
+     */
+    sendVideoToChat(name: string, options?: MessageSendingOptions): void;
+    /**
+     * Unpins message.
+     * @param messageId Message id.
+     */
+    unpinMessage(messageId: number): void;
+}
+//# sourceMappingURL=chatContext.d.ts.map

package/dist/entities/context/chatContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatContext.d.ts","sourceRoot":"","sources":["../../../entities/context/chatContext.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAKrD,OAAO,EACH,qBAAqB,EACrB,yBAAyB,EAC5B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD;;GAEG;AACH,qBAAa,WAAW,CAAC,YAAY,SAAS,YAAY;IACtD,SAAS,CAAC,MAAM,EAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAClD,SAAS,CAAC,YAAY,EAAG,mBAAmB,CAAC;IAC7C,aAAa,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC,CAAM;IACzD,sCAAsC;IACtC,OAAO,EAAG,MAAM,GAAG,MAAM,CAAC;IAC1B,+CAA+C;IAC/C,OAAO,EAAG,MAAM,CAAC;IACjB,+CAA+C;IAC/C,MAAM,EAAG,MAAM,CAAC;IAChB,iDAAiD;IACjD,QAAQ,EAAG,MAAM,CAAC;IAClB,4CAA4C;IAC5C,OAAO,EAAG,cAAc,CAAC;IAEzB,aAAa,UAAS;;IAItB,qBAAqB,CACjB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,CAAC,YAAY,CAAC,EACtC,YAAY,EAAE,mBAAmB,EACjC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,OAAO,EAAE,cAAc;IAgB3B;;;OAGG;IACH,WAAW,CAAC,iBAAiB,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI;IAI5D;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,yBAAyB;IAahE;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;IAc7D;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;IAc7D;;;OAGG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM;CAKjC"}

package/dist/entities/context/chatContext.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatContext = void 0;
+const path_1 = require("path");
+const imageMessage_1 = require("../responses/imageMessage");
+const textMessage_1 = require("../responses/textMessage");
+const videoMessage_1 = require("../responses/videoMessage");
+const unpin_1 = require("../responses/unpin");
+/**
+ * Context of action executed in chat.
+ */
+class ChatContext {
+    constructor() {
+        this.updateActions = [];
+        this.isInitialized = false;
+    }
+    initializeChatContext(botName, action, interactions, chatId, chatName, traceId, storage) {
+        this.botName = botName;
+        this.action = action;
+        this.interactions = interactions;
+        this.chatId = chatId;
+        this.chatName = chatName;
+        this.traceId = traceId;
+        this.storage = storage;
+        this.updateActions = [];
+        this.isInitialized = true;
+        return this;
+    }
+    /**
+     * Manually update the state of an action.
+     * @param stateUpdateAction Function that will modify state.
+     */
+    updateState(stateUpdateAction) {
+        this.updateActions.push(stateUpdateAction);
+    }
+    /**
+     * Sends text message to chat.
+     * @param text Message contents.
+     * @param options Message sending option.
+     */
+    sendTextToChat(text, options) {
+        this.interactions.respond(new textMessage_1.TextMessage(text, this.chatId, undefined, this.traceId, this.action, options));
+    }
+    /**
+     * Sends image message to chat.
+     * @param name Message contents.
+     * @param options Message sending option.
+     */
+    sendImageToChat(name, options) {
+        const filePath = `./content/${name}.png`;
+        this.interactions.respond(new imageMessage_1.ImageMessage({ source: (0, path_1.resolve)(filePath) }, this.chatId, undefined, this.traceId, this.action, options));
+    }
+    /**
+     * Sends video/gif message to chat.
+     * @param name Message contents.
+     * @param options Message sending option.
+     */
+    sendVideoToChat(name, options) {
+        const filePath = `./content/${name}.mp4`;
+        this.interactions.respond(new videoMessage_1.VideoMessage({ source: (0, path_1.resolve)(filePath) }, this.chatId, undefined, this.traceId, this.action, options));
+    }
+    /**
+     * Unpins message.
+     * @param messageId Message id.
+     */
+    unpinMessage(messageId) {
+        this.interactions.unpin(new unpin_1.UnpinResponse(messageId, this.chatId, this.traceId, this.action));
+    }
+}
+exports.ChatContext = ChatContext;