chz-telegram-bot 0.7.13 → 0.7.15

package/src/services/jsonFileStorage.ts

@@ -1,181 +0,0 @@
-import { existsSync, mkdirSync, readFileSync } from 'fs';
-import { writeFile } from 'fs/promises';
-import { Sema as Semaphore } from 'async-sema';
-import { IStorageClient } from '../types/storage';
-import { IActionState } from '../types/actionState';
-import { IActionWithState, ActionKey } from '../types/action';
-import { getOrSetIfNotExists } from '../helpers/mapUtils';
-
-function buildPath(storagePath: string, botName: string, actionKey: string) {
-    return `${storagePath}/${botName}/${actionKey.replaceAll(':', '/')}.json`;
-}
-
-class CachedDataSource {
-    private readonly cache: Map<string, Record<number, IActionState>>;
-    private readonly filePaths = new Map<ActionKey, string>();
-    private readonly botName: string;
-    private readonly storagePath: string;
-
-    constructor(
-        botName: string,
-        actions: IActionWithState<IActionState>[],
-        path?: string
-    ) {
-        this.cache = new Map<string, Record<number, IActionState>>();
-        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.filePaths.set(
-                action.key,
-                buildPath(this.storagePath, this.botName, action.key)
-            );
-        }
-    }
-
-    private tryGetFromCache<TActionState extends IActionState>(key: ActionKey) {
-        const cachedValue = this.cache.get(key) as
-            | Record<number, TActionState>
-            | undefined;
-
-        return cachedValue;
-    }
-
-    private loadFromFile<TActionState extends IActionState>(key: ActionKey) {
-        const targetPath = getOrSetIfNotExists(
-            this.filePaths,
-            key,
-            buildPath(this.storagePath, this.botName, key)
-        );
-
-        const fileContent = readFileSync(targetPath, {
-            encoding: 'utf-8',
-            flag: 'a+'
-        });
-
-        if (fileContent) {
-            const data = JSON.parse(fileContent) as Record<
-                number,
-                TActionState
-            >;
-
-            this.cache.set(key, data);
-        } else {
-            this.cache.set(key, {});
-        }
-
-        return this.cache.get(key) as Record<number, TActionState>;
-    }
-
-    public load<TActionState extends IActionState>(
-        action: IActionWithState<TActionState>
-    ) {
-        return (
-            this.tryGetFromCache<TActionState>(action.key) ??
-            this.loadFromFile<TActionState>(action.key)
-        );
-    }
-
-    public async save<TActionState extends IActionState>(
-        data: Record<number, TActionState>,
-        action: IActionWithState<TActionState>
-    ) {
-        this.cache.set(action.key, data);
-
-        const targetPath = getOrSetIfNotExists(
-            this.filePaths,
-            action.key,
-            buildPath(this.storagePath, this.botName, action.key)
-        );
-
-        await writeFile(targetPath, JSON.stringify(data), { flag: 'w+' });
-    }
-}
-
-export class JsonFileStorage implements IStorageClient {
-    private readonly locks = new Map<ActionKey, Semaphore>();
-
-    private readonly data: CachedDataSource;
-
-    constructor(
-        botName: string,
-        actions: IActionWithState<IActionState>[],
-        path?: string
-    ) {
-        this.data = new CachedDataSource(botName, actions, path ?? 'storage');
-
-        for (const action of actions) {
-            this.locks.set(action.key, new Semaphore(1));
-        }
-    }
-
-    private async lock<TType>(key: ActionKey, action: () => Promise<TType>) {
-        const lock = getOrSetIfNotExists(this.locks, key, new Semaphore(1));
-
-        await lock.acquire();
-
-        try {
-            return await action();
-        } finally {
-            lock.release();
-        }
-    }
-
-    load<TActionState extends IActionState>(
-        action: IActionWithState<TActionState>
-    ) {
-        return this.data.load<TActionState>(action);
-    }
-
-    getActionState<TActionState extends IActionState>(
-        action: IActionWithState<TActionState>,
-        chatId: number
-    ) {
-        const value = this.data.load<TActionState>(action);
-
-        return value[chatId] ?? action.stateConstructor();
-    }
-
-    async saveActionExecutionResult<TActionState extends IActionState>(
-        action: IActionWithState<TActionState>,
-        chatId: number,
-        state: TActionState
-    ) {
-        await this.lock(action.key, async () => {
-            const data = this.data.load(action);
-
-            data[chatId] = state;
-
-            await this.data.save(data, action);
-        });
-    }
-
-    async close(): Promise<void> {
-        for (const lock of this.locks.values()) {
-            await lock.acquire();
-        }
-    }
-
-    async updateStateFor<TActionState extends IActionState>(
-        action: IActionWithState<TActionState>,
-        chatId: number,
-        update: (state: TActionState) => Promise<void> | void
-    ) {
-        await this.lock(action.key, async () => {
-            const data = this.data.load(action);
-            const state = data[chatId];
-
-            await update(state);
-
-            data[chatId] = state;
-
-            await this.data.save(data, action);
-        });
-    }
-}

package/src/services/nodeTimeoutScheduler.ts

@@ -1,79 +0,0 @@
-import { TaskRecord } from '../entities/taskRecord';
-import { createTrace } from '../helpers/traceFactory';
-import { BotEventType, TypedEventEmitter } from '../types/events';
-import { IScheduler } from '../types/scheduler';
-import { Milliseconds } from '../types/timeValues';
-
-export class NodeTimeoutScheduler implements IScheduler {
-    readonly activeTasks: TaskRecord[] = [];
-
-    constructor(
-        readonly eventEmitter: TypedEventEmitter,
-        readonly botName: string
-    ) {}
-
-    stopAll() {
-        for (const task of this.activeTasks) {
-            clearInterval(task.taskId);
-        }
-    }
-
-    createTask(
-        name: string,
-        action: () => unknown,
-        interval: Milliseconds,
-        executeRightAway: boolean,
-        ownerName: string
-    ) {
-        const traceId = createTrace(this, this.botName, name);
-        const taskId = setInterval(() => {
-            action();
-            this.eventEmitter.emit(BotEventType.taskRun, {
-                name,
-                ownerName,
-                interval,
-                traceId
-            });
-        }, interval);
-        const task = new TaskRecord(name, taskId, interval, traceId);
-
-        if (executeRightAway) {
-            setImmediate(action);
-        }
-
-        this.eventEmitter.emit(BotEventType.taskCreated, {
-            name,
-            ownerName,
-            interval,
-            traceId
-        });
-
-        this.activeTasks.push(task);
-    }
-
-    createOnetimeTask(
-        name: string,
-        action: () => unknown,
-        delay: Milliseconds,
-        ownerName: string
-    ) {
-        const traceId = createTrace(this, this.botName, name);
-        const actionWrapper = () => {
-            this.eventEmitter.emit(BotEventType.taskRun, {
-                name,
-                ownerName,
-                delay,
-                traceId
-            });
-            action();
-        };
-        setTimeout(actionWrapper, delay);
-
-        this.eventEmitter.emit(BotEventType.taskCreated, {
-            name,
-            ownerName,
-            delay,
-            traceId
-        });
-    }
-}

package/src/services/responseProcessingQueue.ts

@@ -1,57 +0,0 @@
-import { Milliseconds } from '../types/timeValues';
-import { RateLimit } from 'async-sema';
-
-export type QueueItem = {
-    priority: number;
-    callback: () => Promise<void>;
-};
-
-function notEmpty<T>(arr: T[]): arr is [T, ...T[]] {
-    return arr.length > 0;
-}
-
-const TELEGRAM_RATELIMIT_DELAY = 35 as Milliseconds;
-
-export class ResponseProcessingQueue {
-    rateLimiter = RateLimit(1, { timeUnit: TELEGRAM_RATELIMIT_DELAY });
-    items: QueueItem[] = [];
-    isFlushing = false;
-
-    enqueue(item: QueueItem) {
-        if (
-            this.items.length === 0 ||
-            item.priority >= this.items[this.items.length - 1].priority
-        ) {
-            this.items.push(item);
-            return;
-        }
-
-        let insertIndex = this.items.length;
-        while (
-            insertIndex > 0 &&
-            this.items[insertIndex - 1].priority > item.priority
-        ) {
-            insertIndex--;
-        }
-        this.items.splice(insertIndex, 0, item);
-    }
-
-    async flushReadyItems() {
-        if (this.isFlushing) return;
-
-        this.isFlushing = true;
-
-        while (notEmpty(this.items)) {
-            if (Date.now() >= this.items[0].priority) {
-                await this.rateLimiter();
-
-                const [item] = this.items;
-                this.items.shift();
-
-                await item.callback();
-            }
-        }
-
-        this.isFlushing = false;
-    }
-}

package/src/services/telegramApi.ts

@@ -1,278 +0,0 @@
-import { IStorageClient } from '../types/storage';
-import {
-    BotResponse,
-    BotResponseTypes,
-    IReplyResponse
-} from '../types/response';
-import { QueueItem, ResponseProcessingQueue } from './responseProcessingQueue';
-import { IReplyCapture } from '../types/capture';
-import { IActionWithState } from '../types/action';
-import { IActionState } from '../types/actionState';
-import { TraceId } from '../types/trace';
-import { ChatInfo } from '../dtos/chatInfo';
-import { TelegramApiClient, TelegramMessage } from '../types/externalAliases';
-import { BotEventType, TypedEventEmitter } from '../types/events';
-
-export const TELEGRAM_ERROR_QUOTE_INVALID = 'QUOTE_TEXT_INVALID';
-
-export class TelegramApiService {
-    private readonly queue = new ResponseProcessingQueue();
-    private readonly telegram: TelegramApiClient;
-    private readonly storage: IStorageClient;
-    private readonly eventEmitter: TypedEventEmitter;
-    private readonly captureRegistrationCallback: (
-        capture: IReplyCapture,
-        parentMessageId: number,
-        chatInfo: ChatInfo,
-        traceId: TraceId
-    ) => void;
-
-    private readonly botName: string;
-
-    private readonly methodMap: Record<
-        'pin' | keyof typeof BotResponseTypes,
-        string | null
-    > = {
-        inlineQuery: 'answerInlineQuery',
-        text: 'sendMessage',
-        react: 'setMessageReaction',
-        unpin: 'unpinChatMessage',
-        pin: 'pinChatMessage',
-        image: 'sendPhoto',
-        video: 'sendVideo',
-        delay: null
-    };
-
-    constructor(
-        botName: string,
-        telegram: TelegramApiClient,
-        storage: IStorageClient,
-        eventEmitter: TypedEventEmitter,
-        captureRegistrationCallback: (
-            capture: IReplyCapture,
-            parentMessageId: number,
-            chatInfo: ChatInfo,
-            traceId: TraceId
-        ) => void
-    ) {
-        this.telegram = telegram;
-        this.botName = botName;
-        this.storage = storage;
-        this.eventEmitter = eventEmitter;
-        this.captureRegistrationCallback = captureRegistrationCallback;
-    }
-
-    enqueueBatchedResponses(responses: BotResponse[]) {
-        let offset = 0;
-        for (const response of responses) {
-            if (response.kind == 'delay') {
-                offset += response.delay;
-                continue;
-            }
-
-            const queueItem: QueueItem = {
-                callback: async () => {
-                    try {
-                        await this.processResponse(response);
-                    } catch (e) {
-                        const error = e as Error;
-                        if ('message' in (error as { message?: string })) {
-                            const telegramResponse = error as {
-                                message: string;
-                            };
-
-                            if (
-                                telegramResponse.message.includes(
-                                    TELEGRAM_ERROR_QUOTE_INVALID
-                                )
-                            ) {
-                                this.eventEmitter.emit(BotEventType.error, {
-                                    error: new Error(
-                                        'Quote error recieved, retrying without quote'
-                                    ),
-                                    traceId: response.traceId
-                                });
-
-                                try {
-                                    await this.processResponse(response, true);
-                                } catch (e) {
-                                    const error = e as Error;
-                                    this.eventEmitter.emit(BotEventType.error, {
-                                        error,
-                                        traceId: response.traceId
-                                    });
-                                }
-
-                                return;
-                            }
-                        }
-
-                        this.eventEmitter.emit(BotEventType.error, {
-                            error,
-                            traceId: response.traceId
-                        });
-                    }
-                },
-                priority: response.createdAt + offset
-            };
-            this.queue.enqueue(queueItem);
-        }
-    }
-
-    flushResponses() {
-        void this.queue.flushReadyItems();
-    }
-
-    private async pinIfShould(
-        response: IReplyResponse,
-        message: TelegramMessage
-    ) {
-        if (response.shouldPin) {
-            this.eventEmitter.emit(BotEventType.apiRequestSending, {
-                response: null,
-                telegramMethod: this.methodMap['pin'],
-                traceId: response.traceId
-            });
-            await this.telegram.pinChatMessage(
-                response.chatInfo.id,
-                message.message_id,
-                { disable_notification: true }
-            );
-            this.eventEmitter.emit(BotEventType.apiRequestSent, {
-                response: null,
-                telegramMethod: this.methodMap['pin'],
-                traceId: response.traceId
-            });
-
-            await this.storage.updateStateFor(
-                response.action as IActionWithState<IActionState>,
-                response.chatInfo.id,
-                (state) => {
-                    state.pinnedMessages.push(message.message_id);
-                }
-            );
-        }
-    }
-
-    private async processResponse(response: BotResponse, ignoreQuote = false) {
-        const sentMessage = await this.sendApiRequest(response, ignoreQuote);
-        this.eventEmitter.emit(BotEventType.apiRequestSent, {
-            response,
-            telegramMethod: this.methodMap[response.kind],
-            traceId: response.traceId
-        });
-
-        if (sentMessage && 'content' in response) {
-            await this.pinIfShould(response, sentMessage);
-
-            for (const capture of response.captures) {
-                this.captureRegistrationCallback(
-                    capture,
-                    sentMessage.message_id,
-                    response.chatInfo,
-                    response.traceId
-                );
-            }
-        }
-    }
-
-    private async sendApiRequest(
-        response: BotResponse,
-        ignoreQuote: boolean
-    ): Promise<TelegramMessage | null> {
-        this.eventEmitter.emit(BotEventType.apiRequestSending, {
-            response,
-            telegramMethod: this.methodMap[response.kind],
-            traceId: response.traceId
-        });
-
-        switch (response.kind) {
-            case 'text':
-                return await this.telegram.sendMessage(
-                    response.chatInfo.id,
-                    response.content,
-                    {
-                        reply_parameters: response.replyInfo
-                            ? {
-                                  message_id: response.replyInfo.id,
-                                  quote: ignoreQuote
-                                      ? undefined
-                                      : response.replyInfo.quote
-                              }
-                            : undefined,
-                        parse_mode: 'MarkdownV2',
-                        link_preview_options: {
-                            is_disabled: response.disableWebPreview
-                        },
-                        reply_markup: response.keyboard
-                            ? {
-                                  inline_keyboard: response.keyboard
-                              }
-                            : undefined
-                    }
-                );
-            case 'image':
-                return await this.telegram.sendPhoto(
-                    response.chatInfo.id,
-                    response.content,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    response.replyInfo?.id
-                        ? ({
-                              reply_to_message_id: response.replyInfo.id // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                          } as any)
-                        : undefined
-                );
-            case 'video':
-                return await this.telegram.sendVideo(
-                    response.chatInfo.id,
-                    response.content,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    response.replyInfo?.id
-                        ? ({
-                              reply_to_message_id: response.replyInfo.id // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                          } as any)
-                        : undefined
-                );
-            case 'react':
-                await this.telegram.setMessageReaction(
-                    response.chatInfo.id,
-                    response.messageId,
-                    [
-                        {
-                            type: 'emoji',
-                            emoji: response.emoji
-                        }
-                    ]
-                );
-
-                return null;
-            case 'unpin':
-                await this.telegram.unpinChatMessage(
-                    response.chatInfo.id,
-                    response.messageId
-                );
-
-                await this.storage.updateStateFor(
-                    response.action,
-                    response.chatInfo.id,
-                    (state) => {
-                        state.pinnedMessages = state.pinnedMessages.filter(
-                            (x) => x != response.messageId
-                        );
-                    }
-                );
-
-                return null;
-            case 'inlineQuery':
-                await this.telegram.answerInlineQuery(
-                    response.queryId,
-                    response.queryResults,
-                    { cache_time: 0 }
-                );
-
-                return null;
-            case 'delay':
-                return null;
-        }
-    }
-}

package/src/types/action.ts

@@ -1,15 +0,0 @@
-import { BaseContextInternal } from '../entities/context/baseContext';
-import { IActionState } from './actionState';
-import { BotResponse } from './response';
-
-export type ActionKey = string & { __brand: 'actionKey' };
-
-export interface IActionWithState<TActionState extends IActionState>
-    extends IAction {
-    readonly stateConstructor: () => TActionState;
-}
-
-export interface IAction {
-    readonly key: ActionKey;
-    exec(ctx: BaseContextInternal<IAction>): Promise<BotResponse[]>;
-}

package/src/types/actionState.ts

@@ -1,4 +0,0 @@
-export interface IActionState {
-    lastExecutedDate: number;
-    pinnedMessages: number[];
-}

package/src/types/cachedValueAccessor.ts

@@ -1 +0,0 @@
-export type CachedValueAccessor = <TResult>(key: string) => Promise<TResult>;

package/src/types/capture.ts

@@ -1,33 +0,0 @@
-import {
-    ReplyContext,
-    ReplyContextInternal
-} from '../entities/context/replyContext';
-import { IActionState } from './actionState';
-import { CommandTrigger } from './commandTrigger';
-import { IAction } from './action';
-
-export interface ICaptureController {
-    captureReplies: <TParentActionState extends IActionState>(
-        /**
-         * Defines action trigger.
-         * If `string` or `string[]` is provided, will be triggered only on exact message match.
-         * If `RegExp` or `RegExp[]` is provided, will be triggered on successful match.
-         */
-        trigger: CommandTrigger[],
-        /** Callback that will be called on trigger */
-        handler: (
-            replyContext: ReplyContext<TParentActionState>
-        ) => Promise<void>,
-        /** Abort controller to abort capturing manually */
-        abortController?: AbortController
-    ) => void;
-}
-
-export interface IReplyCapture {
-    trigger: CommandTrigger[];
-    handler: (
-        replyContext: ReplyContextInternal<IActionState>
-    ) => Promise<void>;
-    abortController: AbortController;
-    action: IAction;
-}

package/src/types/commandCondition.ts

@@ -1,9 +0,0 @@
-import { MessageContext } from '../entities/context/messageContext';
-import { IActionState } from './actionState';
-
-export type CommandCondition<TActionState extends IActionState> = (
-    /** Context of action executed in chat, in response to a message. */
-    ctx: MessageContext<TActionState>,
-    /** State of an action being executed. */
-    state: TActionState
-) => boolean;

package/src/types/commandTrigger.ts

@@ -1 +0,0 @@
-export type CommandTrigger = string | RegExp;