chz-telegram-bot 0.0.1

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startBot = startBot;
+exports.stopBots = stopBots;
+const promises_1 = require("fs/promises");
+const bot_js_1 = __importDefault(require("./entities/bot.js"));
+const taskScheduler_js_1 = __importDefault(require("./services/taskScheduler.js"));
+const storage_js_1 = __importDefault(require("./services/storage.js"));
+const logger_js_1 = __importDefault(require("./services/logger.js"));
+const bots = [];
+function log(text) {
+    logger_js_1.default.logWithTraceId('ALL BOTS', 'System:Bot', 'System', text);
+}
+async function startBot(name, tokenFile, commands, scheduled, chats) {
+    const token = await (0, promises_1.readFile)(tokenFile, 'utf8');
+    const bot = new bot_js_1.default(name, token, commands, scheduled, chats);
+    bots.push(bot);
+    return bot;
+}
+async function stopBots(reason) {
+    log(`Recieved termination code: ${reason}`);
+    taskScheduler_js_1.default.stopAll();
+    log('Acquiring storage semaphore...');
+    await storage_js_1.default.semaphoreInstance.acquire();
+    log('Stopping bots...');
+    for (const bot of bots) {
+        bot.stop(reason);
+    }
+    process.exit(0);
+}

package/dist/services/logger.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Logger {
+    logWithTraceId(botName, traceId, chatName, text) {
+        console.log(JSON.stringify({ botName, traceId, chatName, text }));
+    }
+    errorWithTraceId(botName, traceId, chatName, errorObj, extraData) {
+        console.error(JSON.stringify({
+            botName,
+            traceId,
+            chatName,
+            errorObj,
+            extraData
+        }));
+    }
+}
+exports.default = new Logger();

package/dist/services/storage.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const async_sema_1 = require("async-sema");
+class Storage {
+    get semaphoreInstance() {
+        return Storage.semaphore;
+    }
+    constructor() {
+        this.cache = new Map();
+    }
+    async lock(action) {
+        await this.semaphoreInstance.acquire();
+        try {
+            return await action();
+        }
+        finally {
+            this.semaphoreInstance.release();
+        }
+    }
+    async loadInternal(key) {
+        if (!this.cache.has(key)) {
+            const targetPath = this.buidPathFromKey(key);
+            if (!(0, fs_1.existsSync)(targetPath)) {
+                return {};
+            }
+            const fileContent = await (0, promises_1.readFile)(targetPath, 'utf8');
+            if (fileContent) {
+                const data = JSON.parse(fileContent);
+                this.cache.set(key, data);
+            }
+        }
+        return this.cache.get(key) ?? {};
+    }
+    async save(data, key) {
+        this.cache.delete(key);
+        const targetPath = this.buidPathFromKey(key);
+        const folderName = (0, path_1.dirname)(targetPath);
+        if (!(0, fs_1.existsSync)(folderName)) {
+            await (0, promises_1.mkdir)(folderName, { recursive: true });
+        }
+        await (0, promises_1.writeFile)(targetPath, JSON.stringify(data), { flag: 'w+' });
+    }
+    buidPathFromKey(key) {
+        return 'storage/' + key.replaceAll(':', '/') + '.json';
+    }
+    async load(key) {
+        return await this.lock(async () => {
+            return this.loadInternal(key);
+        });
+    }
+    async saveMetadata(actions, botName) {
+        return await this.lock(async () => {
+            const targetPath = this.buidPathFromKey(`Metadata-${botName}`);
+            await (0, promises_1.writeFile)(targetPath, JSON.stringify(actions), {
+                flag: 'w+'
+            });
+        });
+    }
+    async getActionState(entity, chatId) {
+        return await this.lock(async () => {
+            const data = await this.loadInternal(entity.key);
+            return data[chatId] ?? entity.stateConstructor();
+        });
+    }
+    async commitTransactionForAction(action, chatId, transactionResult) {
+        await this.lock(async () => {
+            const data = await this.loadInternal(action.key);
+            if (transactionResult.shouldUpdate) {
+                data[chatId] = transactionResult.data;
+                await this.save(data, action.key);
+            }
+        });
+    }
+}
+Storage.semaphore = new async_sema_1.Sema(1);
+exports.default = new Storage();

package/dist/services/taskScheduler.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const taskRecord_1 = __importDefault(require("../entities/taskRecord"));
+const timeConvertions_1 = require("../helpers/timeConvertions");
+const logger_1 = __importDefault(require("./logger"));
+class TaskScheduler {
+    constructor() {
+        this.activeTasks = [];
+    }
+    stopAll() {
+        this.activeTasks.forEach((task) => {
+            clearInterval(task.taskId);
+        });
+    }
+    createTask(name, action, interval, executeRightAway, ownerName) {
+        executeRightAway = executeRightAway ?? false;
+        const taskId = setInterval(action, interval);
+        const task = new taskRecord_1.default(name, taskId, interval);
+        if (executeRightAway) {
+            setTimeout(action, (0, timeConvertions_1.secondsToMilliseconds)(1));
+        }
+        logger_1.default.logWithTraceId(ownerName, `System:TaskScheduler-${ownerName}-${name}`, 'System', `Created task [${taskId}]${name}, that will run every ${interval}ms.`);
+        this.activeTasks.push(task);
+    }
+    createOnetimeTask(name, action, delay, ownerName) {
+        const actionWrapper = () => {
+            logger_1.default.logWithTraceId(ownerName, `System:TaskScheduler-${ownerName}-${name}`, 'System', `Executing delayed oneshot [${taskId}]${name}`);
+            action();
+        };
+        const taskId = setTimeout(actionWrapper, delay);
+        logger_1.default.logWithTraceId(ownerName, `System:TaskScheduler-${ownerName}-${name}`, 'System', `Created oneshot task [${taskId}]${name}, that will run in ${delay}ms.`);
+    }
+}
+exports.default = new TaskScheduler();

package/dist/services/telegramApi.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const messageContext_1 = __importDefault(require("../entities/context/messageContext"));
+const chatContext_1 = __importDefault(require("../entities/context/chatContext"));
+const imageMessage_1 = __importDefault(require("../entities/responses/imageMessage"));
+const textMessage_1 = __importDefault(require("../entities/responses/textMessage"));
+const videoMessage_1 = __importDefault(require("../entities/responses/videoMessage"));
+const taskScheduler_1 = __importDefault(require("./taskScheduler"));
+const logger_1 = __importDefault(require("./logger"));
+const reverseMap_1 = require("../helpers/reverseMap");
+class TelegramApiService {
+    constructor(botName, telegraf, chats) {
+        this.messageQueue = [];
+        this.telegraf = telegraf;
+        this.botName = botName;
+        this.chats = (0, reverseMap_1.reverseMap)(chats);
+        taskScheduler_1.default.createTask('MessageSending', () => {
+            this.dequeueResponse();
+        }, 100, false, this.botName);
+    }
+    async dequeueResponse() {
+        const message = this.messageQueue.pop();
+        if (!message)
+            return;
+        try {
+            await this.processResponse(message);
+        }
+        catch (error) {
+            logger_1.default.errorWithTraceId(this.botName, message.traceId, this.chats.get(message.chatId), error, message);
+        }
+    }
+    async processResponse(response) {
+        if ('emoji' in response) {
+            this.telegraf.telegram.setMessageReaction(response.chatId, response.messageId, [
+                {
+                    type: 'emoji',
+                    emoji: response.emoji
+                }
+            ], true);
+            return;
+        }
+        switch (response.constructor) {
+            case textMessage_1.default:
+                await this.telegraf.telegram.sendMessage(response.chatId, response.content, {
+                    reply_to_message_id: response.replyId,
+                    parse_mode: 'MarkdownV2',
+                    disable_web_page_preview: true
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                });
+                break;
+            case imageMessage_1.default:
+                await this.telegraf.telegram.sendPhoto(response.chatId, response.content, response.replyId
+                    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        { reply_to_message_id: response.replyId }
+                    : undefined);
+                break;
+            case videoMessage_1.default:
+                await this.telegraf.telegram.sendVideo(response.chatId, response.content, response.replyId
+                    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        { reply_to_message_id: response.replyId }
+                    : undefined);
+                break;
+            default:
+                logger_1.default.errorWithTraceId(this.botName, response.traceId, this.chats.get(response.chatId), `Unknown message type: ${response.constructor}`, response);
+                break;
+        }
+    }
+    enqueueResponse(response) {
+        this.messageQueue.push(response);
+    }
+    enqueueReaction(reaction) {
+        this.messageQueue.push(reaction);
+    }
+    getInteractions() {
+        return {
+            react: (reaction) => this.enqueueReaction(reaction),
+            respond: (response) => this.enqueueResponse(response)
+        };
+    }
+    createContextForMessage(incomingMessage) {
+        const firstName = incomingMessage.from?.first_name ?? 'Unknown user';
+        const lastName = incomingMessage.from?.last_name
+            ? ` ${incomingMessage.from?.last_name}`
+            : '';
+        return new messageContext_1.default(this.botName, this.getInteractions(), incomingMessage.chat.id, incomingMessage.chatName, incomingMessage.message_id, incomingMessage.text, incomingMessage.from?.id, incomingMessage.traceId, firstName + lastName);
+    }
+    createContextForChat(chatId, scheduledName) {
+        return new chatContext_1.default(this.botName, this.getInteractions(), chatId, this.chats.get(chatId), `Scheduled:${scheduledName}:${chatId}`);
+    }
+}
+exports.default = TelegramApiService;

package/dist/types/actionState.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/actionWithState.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/cachedValueAccessor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/commandCondition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/daysOfTheWeek.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Day = void 0;
+var Day;
+(function (Day) {
+    Day[Day["Sunday"] = 0] = "Sunday";
+    Day[Day["Monday"] = 1] = "Monday";
+    Day[Day["Tuesday"] = 2] = "Tuesday";
+    Day[Day["Wednesday"] = 3] = "Wednesday";
+    Day[Day["Thursday"] = 4] = "Thursday";
+    Day[Day["Friday"] = 5] = "Friday";
+    Day[Day["Saturday"] = 6] = "Saturday";
+})(Day || (exports.Day = Day = {}));

package/dist/types/handlers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/replyMessage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/scheduledItem.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/timeValues.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/entities/actions/commandAction.ts

@@ -0,0 +1,143 @@
+import storage from '../../services/storage';
+import TransactionResult from '../transactionResult';
+import moment from 'moment';
+import logger from '../../services/logger';
+import MessageContext from '../context/messageContext';
+import IActionWithState from '../../types/actionWithState';
+import toArray from '../../helpers/toArray';
+import IActionState from '../../types/actionState';
+import CommandTriggerCheckResult from '../commandTriggerCheckResult';
+import { CommandHandler } from '../../types/handlers';
+import { CommandCondition } from '../../types/commandCondition';
+import { Seconds } from '../../types/timeValues';
+import { secondsToMilliseconds } from '../../helpers/timeConvertions';
+
+export default class CommandAction<TActionState extends IActionState>
+    implements IActionWithState
+{
+    triggers: (string | RegExp)[];
+    handler: CommandHandler<TActionState>;
+    name: string;
+    cooldownInSeconds: Seconds;
+    active: boolean;
+    chatsBlacklist: number[];
+    allowedUsers: number[];
+    condition: CommandCondition<TActionState>;
+    stateConstructor: () => TActionState;
+    key: string;
+
+    constructor(
+        trigger: string | RegExp | Array<string> | Array<RegExp>,
+        handler: CommandHandler<TActionState>,
+        name: string,
+        active: boolean,
+        cooldown: Seconds,
+        chatsBlacklist: Array<number>,
+        allowedUsers: Array<number>,
+        condition: CommandCondition<TActionState>,
+        stateConstructor: () => TActionState
+    ) {
+        this.triggers = 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: MessageContext<TActionState>) {
+        if (!this.active || this.chatsBlacklist.includes(ctx.chatId)) return;
+
+        const isConditionMet = await this.condition(ctx);
+
+        if (!isConditionMet) return;
+
+        const state = await storage.getActionState<TActionState>(
+            this,
+            ctx.chatId
+        );
+
+        const { shouldTrigger, matchResults, skipCooldown } = this.triggers
+            .map((x) => this.checkTrigger(ctx, x, state))
+            .reduce(
+                (acc, curr) => acc.mergeWith(curr),
+                CommandTriggerCheckResult.DoNotTrigger
+            );
+
+        if (!shouldTrigger) return;
+
+        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 = moment().valueOf();
+        }
+
+        ctx.updateActions.forEach((action) => action(state));
+
+        await storage.commitTransactionForAction(
+            this,
+            ctx.chatId,
+            new TransactionResult(state, ctx.startCooldown && shouldTrigger)
+        );
+    }
+
+    private checkTrigger(
+        ctx: MessageContext<TActionState>,
+        trigger: RegExp | string,
+        state: IActionState
+    ) {
+        let shouldTrigger = false;
+        const matchResults: RegExpExecArray[] = [];
+
+        if (!ctx.fromUserId)
+            return CommandTriggerCheckResult.DontTriggerAndSkipCooldown;
+
+        const isUserAllowed =
+            this.allowedUsers.length == 0 ||
+            this.allowedUsers.includes(ctx.fromUserId);
+        const cooldownInMilliseconds = secondsToMilliseconds(
+            this.cooldownInSeconds
+        );
+        const notOnCooldown =
+            moment().valueOf() - state.lastExecutedDate >=
+            cooldownInMilliseconds;
+
+        if (isUserAllowed && notOnCooldown) {
+            if (typeof trigger == 'string') {
+                shouldTrigger = ctx.messageText.toLowerCase() == trigger;
+            } else {
+                let matchCount = ctx.messageText.match(trigger)?.length ?? 0;
+                if (matchCount > 0) {
+                    for (; matchCount > 0; matchCount--) {
+                        const execResult = trigger.exec(ctx.messageText);
+                        if (execResult) matchResults.push(execResult);
+                    }
+                    shouldTrigger = true;
+                }
+            }
+        }
+
+        return new CommandTriggerCheckResult(
+            shouldTrigger,
+            matchResults,
+            !isUserAllowed
+        );
+    }
+}

package/entities/actions/scheduledAction.ts

@@ -0,0 +1,121 @@
+import storage from '../../services/storage';
+import TransactionResult from '../transactionResult';
+import moment from 'moment';
+import logger from '../../services/logger';
+import taskScheduler from '../../services/taskScheduler';
+import { Sema as Semaphore } from 'async-sema';
+import ChatContext from '../context/chatContext';
+import IActionWithState from '../../types/actionWithState';
+import ActionStateBase from '../states/actionStateBase';
+import IActionState from '../../types/actionState';
+import { ScheduledHandler } from '../../types/handlers';
+import CachedStateFactory from '../cachedStateFactory';
+import { hoursToMilliseconds } from '../../helpers/timeConvertions';
+import { HoursOfDay } from '../../types/timeValues';
+
+export default class ScheduledAction implements IActionWithState {
+    static semaphore = new Semaphore(1);
+
+    name: string;
+    timeinHours: HoursOfDay;
+    active: boolean;
+    chatsWhitelist: number[];
+    key: string;
+
+    cachedState = new Map<string, unknown>();
+    stateConstructor = () => new ActionStateBase();
+    cachedStateFactories: Map<string, CachedStateFactory>;
+    handler: ScheduledHandler;
+
+    constructor(
+        name: string,
+        handler: ScheduledHandler,
+        timeinHours: HoursOfDay,
+        active: boolean,
+        whitelist: number[],
+        cachedStateFactories: Map<string, CachedStateFactory>
+    ) {
+        this.name = name;
+        this.handler = handler;
+        this.timeinHours = timeinHours;
+        this.active = active;
+        this.chatsWhitelist = whitelist;
+        this.cachedStateFactories = cachedStateFactories;
+        this.key = `scheduled:${this.name.replace('.', '-')}`;
+    }
+
+    async exec(ctx: ChatContext) {
+        if (!this.active || !this.chatsWhitelist.includes(ctx.chatId)) return;
+
+        const state = await storage.getActionState(this, ctx.chatId);
+        const isAllowedToTrigger = this.shouldTrigger(state);
+
+        if (isAllowedToTrigger) {
+            logger.logWithTraceId(
+                ctx.botName,
+                ctx.traceId,
+                ctx.chatName,
+                ` - Executing [${this.name}] in ${ctx.chatId}`
+            );
+
+            await this.handler(ctx, <TResult>(key: string) =>
+                this.getCachedValue<TResult>(key, ctx.botName)
+            );
+
+            state.lastExecutedDate = moment().valueOf();
+
+            await storage.commitTransactionForAction(
+                this,
+                ctx.chatId,
+                new TransactionResult(state, isAllowedToTrigger)
+            );
+        }
+    }
+
+    private async getCachedValue<TResult>(
+        key: string,
+        botName: string
+    ): Promise<TResult> {
+        if (!this.cachedStateFactories.has(key)) {
+            throw new Error(
+                `No shared cache was set up for the key [${key}] in action '${this.name}'`
+            );
+        }
+
+        await ScheduledAction.semaphore.acquire();
+
+        try {
+            if (this.cachedState.has(key)) {
+                return this.cachedState.get(key) as TResult;
+            }
+
+            const cachedItemFactory = this.cachedStateFactories.get(key)!;
+            const value = await cachedItemFactory.getValue();
+
+            this.cachedState.set(key, value);
+
+            taskScheduler.createOnetimeTask(
+                `Drop cached value [${this.name} : ${key}]`,
+                () => this.cachedState.delete(key),
+                hoursToMilliseconds(
+                    cachedItemFactory.invalidationTimeoutInHours
+                ),
+                botName
+            );
+
+            return value as TResult;
+        } finally {
+            ScheduledAction.semaphore.release();
+        }
+    }
+
+    private shouldTrigger(state: IActionState): boolean {
+        const today = moment().startOf('day').valueOf();
+
+        const isAllowedToTrigger =
+            moment().hour().valueOf() >= this.timeinHours;
+        const hasTriggeredToday = state.lastExecutedDate >= today;
+
+        return isAllowedToTrigger && !hasTriggeredToday;
+    }
+}