chz-telegram-bot 0.0.1

package/entities/bot.ts

@@ -0,0 +1,143 @@
+import { Telegraf } from 'telegraf';
+import TelegramApiService from '../services/telegramApi';
+import IncomingMessage from './incomingMessage';
+import taskScheduler from '../services/taskScheduler';
+import logger from '../services/logger';
+import CommandAction from './actions/commandAction';
+import ScheduledAction from './actions/scheduledAction';
+import IActionState from '../types/actionState';
+import {
+    hoursToMilliseconds,
+    secondsToMilliseconds
+} from '../helpers/timeConvertions';
+import { Hours, Seconds } from '../types/timeValues';
+import storage from '../services/storage';
+
+export default class Bot {
+    name: string;
+    api: TelegramApiService;
+    telegraf: Telegraf;
+    commands: CommandAction<IActionState>[];
+    scheduled: ScheduledAction[];
+    chats: Map<string, number>;
+    messageQueue: IncomingMessage[] = [];
+
+    constructor(
+        name: string,
+        token: string,
+        commands: CommandAction<IActionState>[],
+        scheduled: ScheduledAction[],
+        chats: Map<string, number>
+    ) {
+        this.name = name;
+        this.commands = commands;
+        this.scheduled = scheduled;
+        this.chats = chats;
+
+        logger.logWithTraceId(
+            this.name,
+            `System:Bot-${this.name}-Start`,
+            'System',
+            'Starting bot...'
+        );
+        this.telegraf = new Telegraf(token);
+
+        this.api = new TelegramApiService(this.name, this.telegraf, this.chats);
+
+        this.telegraf.on('message', async (ctx) => {
+            const msg = new IncomingMessage(ctx.update.message);
+            const messageContent = msg.text || '<non-text message>';
+
+            const messageFromName = msg.from?.first_name ?? 'Unknown';
+            const messageFromId = msg.from?.id ?? 'Unknown';
+            logger.logWithTraceId(
+                this.name,
+                msg.traceId,
+                msg.chatName,
+                `${messageFromName} (${messageFromId}): ${messageContent}`
+            );
+
+            if (msg.text) {
+                this.messageQueue.push(msg);
+            }
+        });
+
+        this.telegraf.launch();
+
+        taskScheduler.createTask(
+            'MessageProcessing',
+            async () => {
+                while (this.messageQueue.length > 0) {
+                    await this.processMessages();
+                }
+            },
+            secondsToMilliseconds(0.3 as Seconds),
+            false,
+            this.name
+        );
+
+        taskScheduler.createTask(
+            'ScheduledProcessing',
+            async () => {
+                await this.runScheduled();
+            },
+            hoursToMilliseconds(0.5 as Hours),
+            true,
+            this.name
+        );
+
+        storage.saveMetadata([...this.commands, ...this.scheduled], this.name);
+    }
+
+    stop(code: string) {
+        logger.logWithTraceId(
+            this.name,
+            `System:Bot-${this.name}-Stop`,
+            'System',
+            'Stopping bot...'
+        );
+
+        this.telegraf.stop(code);
+    }
+
+    private async runScheduled() {
+        for (const [chatName, chatId] of this.chats.entries()) {
+            for (const trig of this.scheduled) {
+                const ctx = this.api.createContextForChat(chatId, trig.name);
+
+                try {
+                    await trig.exec(ctx);
+                } catch (error) {
+                    console.dir(error);
+                    logger.errorWithTraceId(
+                        ctx.botName,
+                        ctx.traceId,
+                        chatName,
+                        error as string | Error,
+                        ctx
+                    );
+                }
+            }
+        }
+    }
+
+    private async processMessages() {
+        const msg = this.messageQueue.pop()!;
+
+        for (const cmd of this.commands) {
+            const ctx = this.api.createContextForMessage(msg);
+
+            try {
+                await cmd.exec(ctx);
+            } catch (error) {
+                logger.errorWithTraceId(
+                    ctx.botName,
+                    ctx.traceId,
+                    ctx.chatName,
+                    error as string | Error,
+                    ctx
+                );
+            }
+        }
+    }
+}

package/entities/cachedStateFactory.ts

@@ -0,0 +1,14 @@
+import { Hours } from '../types/timeValues';
+
+export default class CachedStateFactory {
+    getValue: () => Promise<unknown>;
+    invalidationTimeoutInHours: Hours;
+
+    constructor(
+        itemFactory: () => Promise<unknown>,
+        invalidationTimeout: Hours
+    ) {
+        this.getValue = itemFactory;
+        this.invalidationTimeoutInHours = invalidationTimeout;
+    }
+}

package/entities/commandTriggerCheckResult.ts

@@ -0,0 +1,30 @@
+export default class CommandTriggerCheckResult {
+    static get DontTriggerAndSkipCooldown() {
+        return new CommandTriggerCheckResult(false, [], true);
+    }
+    static get DoNotTrigger() {
+        return new CommandTriggerCheckResult(false, [], false);
+    }
+
+    shouldTrigger: boolean;
+    matchResults: RegExpExecArray[];
+    skipCooldown: boolean;
+
+    constructor(
+        shouldTrigger: boolean,
+        matchResults: RegExpExecArray[],
+        skipCooldown: boolean
+    ) {
+        this.shouldTrigger = shouldTrigger;
+        this.matchResults = matchResults;
+        this.skipCooldown = skipCooldown;
+    }
+
+    mergeWith(other: CommandTriggerCheckResult) {
+        this.shouldTrigger = this.shouldTrigger || other.shouldTrigger;
+        this.matchResults = this.matchResults.concat(other.matchResults);
+        this.skipCooldown = this.skipCooldown || other.skipCooldown;
+
+        return this;
+    }
+}

package/entities/context/chatContext.ts

@@ -0,0 +1,57 @@
+import ImageMessage from '../responses/imageMessage';
+import TextMessage from '../responses/textMessage';
+import VideoMessage from '../responses/videoMessage';
+import { resolve } from 'path';
+import { IBotApiInteractions } from '../../services/telegramApi';
+
+export default class ChatContext {
+    botName: string;
+    interactions: IBotApiInteractions;
+    chatId: number;
+    chatName: string;
+    traceId: number | string;
+
+    constructor(
+        botName: string,
+        interactions: IBotApiInteractions,
+        chatId: number,
+        chatName: string,
+        traceId: number | string
+    ) {
+        this.botName = botName;
+        this.interactions = interactions;
+        this.chatId = chatId;
+        this.chatName = chatName;
+        this.traceId = traceId;
+    }
+
+    sendTextToChat(text: string) {
+        this.interactions.respond(
+            new TextMessage(text, this.chatId, undefined, this.traceId)
+        );
+    }
+
+    sendImageToChat(name: string) {
+        const filePath = `./content/${name}.png`;
+        this.interactions.respond(
+            new ImageMessage(
+                { source: resolve(filePath) },
+                this.chatId,
+                undefined,
+                this.traceId
+            )
+        );
+    }
+
+    sendVideoToChat(name: string) {
+        const filePath = `./content/${name}.mp4`;
+        this.interactions.respond(
+            new VideoMessage(
+                { source: resolve(filePath) },
+                this.chatId,
+                undefined,
+                this.traceId
+            )
+        );
+    }
+}

package/entities/context/messageContext.ts

@@ -0,0 +1,94 @@
+import ActionStateBase from '../states/actionStateBase';
+import ImageMessage from '../responses/imageMessage';
+import TextMessage from '../responses/textMessage';
+import VideoMessage from '../responses/videoMessage';
+import ChatContext from './chatContext';
+import storage from '../../services/storage';
+import { resolve } from 'path';
+import IActionState from '../../types/actionState';
+import { IBotApiInteractions } from '../../services/telegramApi';
+import { TelegramEmoji } from 'telegraf/types';
+import Reaction from '../responses/reaction';
+
+export default class MessageContext<
+    TActionState extends IActionState
+> extends ChatContext {
+    messageId: number;
+    messageText: string;
+    matchResults: RegExpMatchArray[] = [];
+    fromUserId: number | undefined;
+    startCooldown: boolean = true;
+    updateActions: Array<(state: TActionState) => void> = [];
+    fromUserName: string;
+
+    constructor(
+        botName: string,
+        interactions: IBotApiInteractions,
+        chatId: number,
+        chatName: string,
+        messageId: number,
+        messageText: string,
+        fromUserId: number | undefined,
+        traceId: number | string,
+        fromUserName: string
+    ) {
+        super(botName, interactions, chatId, chatName, traceId);
+
+        this.messageId = messageId;
+        this.messageText = messageText;
+        this.fromUserId = fromUserId;
+        this.fromUserName = fromUserName;
+    }
+
+    async loadStateOf<TAnotherActionState extends IActionState>(
+        commandName: string
+    ): Promise<TAnotherActionState> {
+        return (
+            ((await storage.load(`command:${commandName.replace('.', '-')}`))[
+                this.chatId
+            ] as TAnotherActionState) ?? new ActionStateBase()
+        );
+    }
+
+    updateState(stateUpdateAction: (state: TActionState) => void) {
+        this.updateActions.push(
+            stateUpdateAction as (state: TActionState) => void
+        );
+    }
+
+    replyWithText(text: string) {
+        this.interactions.respond(
+            new TextMessage(text, this.chatId, this.messageId, this.traceId)
+        );
+    }
+
+    replyWithImage(name: string) {
+        const filePath = `./content/${name}.png`;
+        this.interactions.respond(
+            new ImageMessage(
+                { source: resolve(filePath) },
+                this.chatId,
+                this.messageId,
+                this.traceId
+            )
+        );
+    }
+
+    replyWithVideo(name: string) {
+        const filePath = `./content/${name}.mp4`;
+        this.interactions.respond(
+            new VideoMessage(
+                { source: resolve(filePath) },
+                this.chatId,
+                this.messageId,
+                this.traceId
+            )
+        );
+    }
+
+    react(emoji: TelegramEmoji) {
+        this.interactions.react(
+            new Reaction(this.traceId, this.chatId, this.messageId, emoji)
+        );
+    }
+}

package/entities/incomingMessage.ts

@@ -0,0 +1,27 @@
+import { Chat, User } from 'telegraf/types';
+import randomInteger from '../helpers/randomInt';
+
+export default class IncomingMessage {
+    message_id: number;
+    chat: Chat;
+    from: User | undefined;
+    text: string;
+    chatName: string;
+    traceId = randomInteger(10000, 99999);
+
+    constructor(ctxMessage: {
+        message_id: number;
+        chat: Chat;
+        from?: User;
+        text?: string;
+    }) {
+        this.message_id = ctxMessage.message_id;
+        this.chat = ctxMessage.chat;
+        this.from = ctxMessage.from;
+        this.text = ctxMessage.text || '';
+        this.chatName =
+            'title' in ctxMessage.chat
+                ? ctxMessage.chat.title + ' ' + ctxMessage.chat.id
+                : 'DM';
+    }
+}

package/entities/responses/imageMessage.ts

@@ -0,0 +1,21 @@
+import { InputFile } from 'telegraf/types';
+import IReplyMessage from '../../types/replyMessage';
+
+export default class ImageMessage implements IReplyMessage<InputFile> {
+    content: InputFile;
+    chatId: number;
+    replyId: number | undefined;
+    traceId: string | number;
+
+    constructor(
+        image: InputFile,
+        chatId: number,
+        replyId: number | undefined,
+        traceId: number | string
+    ) {
+        this.content = image;
+        this.chatId = chatId;
+        this.replyId = replyId;
+        this.traceId = traceId;
+    }
+}

package/entities/responses/reaction.ts

@@ -0,0 +1,20 @@
+import { TelegramEmoji } from 'telegraf/types';
+
+export default class Reaction {
+    chatId: number;
+    messageId: number;
+    traceId: number | string;
+    emoji: TelegramEmoji;
+
+    constructor(
+        traceId: number | string,
+        chatId: number,
+        messageId: number,
+        emoji: TelegramEmoji
+    ) {
+        this.chatId = chatId;
+        this.messageId = messageId;
+        this.emoji = emoji;
+        this.traceId = traceId;
+    }
+}

package/entities/responses/textMessage.ts

@@ -0,0 +1,20 @@
+import IReplyMessage from '../../types/replyMessage';
+
+export default class TextMessage implements IReplyMessage<string> {
+    content: string;
+    chatId: number;
+    replyId: number | undefined;
+    traceId: string | number;
+
+    constructor(
+        text: string,
+        chatId: number,
+        replyId: number | undefined,
+        traceId: string | number
+    ) {
+        this.content = text;
+        this.chatId = chatId;
+        this.replyId = replyId;
+        this.traceId = traceId;
+    }
+}

package/entities/responses/videoMessage.ts

@@ -0,0 +1,21 @@
+import { InputFile } from 'telegraf/types';
+import IReplyMessage from '../../types/replyMessage';
+
+export default class VideoMessage implements IReplyMessage<InputFile> {
+    content: InputFile;
+    chatId: number;
+    replyId: number | undefined;
+    traceId: string | number;
+
+    constructor(
+        video: InputFile,
+        chatId: number,
+        replyId: number | undefined,
+        traceId: number | string
+    ) {
+        this.content = video;
+        this.chatId = chatId;
+        this.replyId = replyId;
+        this.traceId = traceId;
+    }
+}

package/entities/states/actionStateBase.ts

@@ -0,0 +1,5 @@
+import IActionState from '../../types/actionState';
+
+export default class ActionStateBase implements IActionState {
+    lastExecutedDate = 0;
+}

package/entities/states/potuzhnoState.ts

@@ -0,0 +1,5 @@
+import ActionStateBase from './actionStateBase';
+
+export default class PotuzhnoState extends ActionStateBase {
+    scoreBoard: Record<string, number> = {};
+}

package/entities/taskRecord.ts

@@ -0,0 +1,13 @@
+import { Milliseconds } from '../types/timeValues';
+
+export default class TaskRecord {
+    name: string;
+    taskId: NodeJS.Timeout;
+    interval: Milliseconds;
+
+    constructor(name: string, taskId: NodeJS.Timeout, interval: Milliseconds) {
+        this.name = name;
+        this.taskId = taskId;
+        this.interval = interval;
+    }
+}

package/entities/transactionResult.ts

@@ -0,0 +1,11 @@
+import IActionState from '../types/actionState';
+
+export default class TransactionResult {
+    data: IActionState;
+    shouldUpdate: boolean;
+
+    constructor(data: IActionState, shouldUpdate: boolean) {
+        this.data = data;
+        this.shouldUpdate = shouldUpdate;
+    }
+}

package/eslint.config.js

@@ -0,0 +1,10 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    ignores: ["build/*"]
+  },
+);

package/helpers/builders/commandActionBuilder.ts

@@ -0,0 +1,88 @@
+import CommandAction from '../../entities/actions/commandAction';
+import ActionStateBase from '../../entities/states/actionStateBase';
+import toArray from '../toArray';
+import IActionState from '../../types/actionState';
+import { CommandHandler } from '../../types/handlers';
+import { CommandCondition } from '../../types/commandCondition';
+import { Seconds } from '../../types/timeValues';
+import Noop from '../noop';
+
+export class CommandActionBuilderWithState<TActionState extends IActionState> {
+    name: string;
+    trigger: string | RegExp | Array<string> | Array<RegExp> = [];
+
+    active = true;
+    cooldownSeconds: Seconds = 0 as Seconds;
+    blacklist: number[] = [];
+    allowedUsers: number[] = [];
+    stateConstructor: () => TActionState;
+    handler: CommandHandler<TActionState> = Noop.call;
+    condition: CommandCondition<TActionState> = Noop.true;
+
+    constructor(name: string, stateConstructor: () => TActionState) {
+        this.name = name;
+        this.stateConstructor = stateConstructor;
+    }
+
+    on(trigger: string | RegExp | Array<string> | Array<RegExp>) {
+        this.trigger = trigger;
+
+        return this;
+    }
+
+    from(id: number | Array<number>) {
+        this.allowedUsers = toArray(id);
+
+        return this;
+    }
+
+    do(handler: CommandHandler<TActionState>) {
+        this.handler = handler;
+
+        return this;
+    }
+
+    when(condition: CommandCondition<TActionState>) {
+        this.condition = condition;
+
+        return this;
+    }
+
+    disabled() {
+        this.active = false;
+
+        return this;
+    }
+
+    cooldown(seconds: Seconds) {
+        this.cooldownSeconds = seconds;
+
+        return this;
+    }
+
+    ignoreChat(chatId: number) {
+        this.blacklist.push(chatId);
+
+        return this;
+    }
+
+    build() {
+        return new CommandAction(
+            this.trigger,
+            this.handler,
+            this.name,
+            this.active,
+            this.cooldownSeconds,
+            this.blacklist,
+            this.allowedUsers,
+            this.condition,
+            this.stateConstructor
+        );
+    }
+}
+
+export class CommandActionBuilder extends CommandActionBuilderWithState<ActionStateBase> {
+    constructor(name: string) {
+        super(name, () => new ActionStateBase());
+    }
+}

package/helpers/builders/scheduledActionBuilder.ts

@@ -0,0 +1,67 @@
+import ScheduledAction from '../../entities/actions/scheduledAction';
+import CachedStateFactory from '../../entities/cachedStateFactory';
+import { ScheduledHandler } from '../../types/handlers';
+import { Hours, HoursOfDay } from '../../types/timeValues';
+import Noop from '../noop';
+
+export default class ScheduledActionBuilder {
+    active = true;
+    time: HoursOfDay = 0;
+    cachedStateFactories = new Map<string, CachedStateFactory>();
+    whitelist: number[] = [];
+    handler: ScheduledHandler = Noop.call;
+
+    name: string;
+
+    constructor(name: string) {
+        this.name = name;
+    }
+
+    allowIn(chatId: number) {
+        this.whitelist.push(chatId);
+
+        return this;
+    }
+
+    runAt(time: HoursOfDay) {
+        this.time = time;
+
+        return this;
+    }
+
+    do(handler: ScheduledHandler) {
+        this.handler = handler;
+
+        return this;
+    }
+
+    withSharedCache(
+        key: string,
+        itemFactory: () => Promise<unknown>,
+        invalidationTimeoutInHours: Hours = 20 as Hours
+    ) {
+        this.cachedStateFactories.set(
+            key,
+            new CachedStateFactory(itemFactory, invalidationTimeoutInHours)
+        );
+
+        return this;
+    }
+
+    disabled() {
+        this.active = false;
+
+        return this;
+    }
+
+    build() {
+        return new ScheduledAction(
+            this.name,
+            this.handler,
+            this.time,
+            this.active,
+            this.whitelist,
+            this.cachedStateFactories
+        );
+    }
+}

package/helpers/escapeMarkdown.ts

@@ -0,0 +1,12 @@
+import escape from 'markdown-escape';
+
+export default function escapeMarkdown(text: string) {
+    return escape(text)
+        .replaceAll(/\./g, '\\.')
+        .replaceAll(/-/g, '\\-')
+        .replaceAll(/\+/g, '\\+')
+        .replaceAll(/\{/g, '\\{')
+        .replaceAll(/!/g, '\\!')
+        .replaceAll(/\|/g, '\\|')
+        .replaceAll(/\}/g, '\\}');
+}

package/helpers/getWeek.ts

@@ -0,0 +1,8 @@
+import moment from 'moment';
+
+export default function getCurrentWeek() {
+    const firstDay = moment().startOf('isoWeek').format('YYYY-MM-DD');
+    const lastDay = moment().endOf('isoWeek').format('YYYY-MM-DD');
+
+    return { firstDay, lastDay };
+}