chz-telegram-bot 0.7.13 → 0.7.15

package/src/helpers/builders/scheduledActionBuilder.ts

@@ -1,143 +0,0 @@
-import { ScheduledAction } from '../../entities/actions/scheduledAction';
-import { CachedStateFactory } from '../../entities/cachedStateFactory';
-import { ActionStateBase } from '../../entities/states/actionStateBase';
-import { IActionState } from '../../types/actionState';
-import { ScheduledHandler } from '../../types/handlers';
-import { ScheduledActionPropertyProvider } from '../../types/propertyProvider';
-import { Hours, HoursOfDay } from '../../types/timeValues';
-import { Noop } from '../noop';
-
-/**
- * Builder for `ScheduledAction` with state represented by `TActionState`
- */
-export class ScheduledActionBuilderWithState<
-    TActionState extends IActionState
-> {
-    private readonly name: string;
-    private readonly cachedStateFactories = new Map<
-        string,
-        CachedStateFactory
-    >();
-    private readonly stateConstructor: () => TActionState;
-    private handler: ScheduledHandler<TActionState> = Noop.call;
-
-    private whitelistProvider: ScheduledActionPropertyProvider<number[]> =
-        () => [];
-    private activeProvider: ScheduledActionPropertyProvider<boolean> = () =>
-        true;
-    private timeinHoursProvider: ScheduledActionPropertyProvider<HoursOfDay> =
-        () => 0;
-
-    /**
-     * Builder for `ScheduledAction` with state represented by `TActionState`
-     * @param name Action name, will be used for logging and storage
-     * @param stateConstructor Function that creates default state object
-     */
-    constructor(name: string, stateConstructor: () => TActionState) {
-        this.name = name;
-        this.stateConstructor = stateConstructor;
-    }
-
-    /**
-     * Sets whitelist for this action.
-     * @param chatIds Chat ids to execute in.
-     */
-    in(chatIds: number[]) {
-        this.whitelistProvider = () => chatIds;
-
-        return this;
-    }
-
-    /**
-     * Defines time for scheduled item execution.
-     * @param time Time of day (0 - 23) to execute action.
-     */
-    runAt(time: HoursOfDay) {
-        this.timeinHoursProvider = () => time;
-
-        return this;
-    }
-
-    /** Defines action logic itself, will be executed on timer.
-     * @param handler Callback that will be called on timer.
-     */
-    do(handler: ScheduledHandler<TActionState>) {
-        this.handler = handler;
-
-        return this;
-    }
-
-    /**
-     * Defines process-wide cache, that is shared by all actions of this type (even in different bot instances).
-     * Can be used for fetch request de-duping, etc.
-     * @param key Key that will be used to retrieve value from cache.
-     * @param itemFactory Callback that will be executed once to create cached value.
-     * @param invalidationTimeoutInHours Timeout for cache invalidation.
-     */
-    withSharedCache(
-        key: string,
-        itemFactory: () => Promise<unknown>,
-        invalidationTimeoutInHours: Hours = 20 as Hours
-    ) {
-        this.cachedStateFactories.set(
-            key,
-            new CachedStateFactory(itemFactory, invalidationTimeoutInHours)
-        );
-
-        return this;
-    }
-
-    /** If called during building, action is marked as disabled and never checked. */
-    disabled() {
-        this.activeProvider = () => false;
-
-        return this;
-    }
-
-    /**
-     * Configures action to use property value providers instead of static value to allow changes in runtime
-     */
-    withConfiguration(configuration: {
-        timeinHoursProvider?: ScheduledActionPropertyProvider<HoursOfDay>;
-        isActiveProvider?: ScheduledActionPropertyProvider<boolean>;
-        chatsWhitelistProvider?: ScheduledActionPropertyProvider<number[]>;
-    }) {
-        if (configuration.chatsWhitelistProvider)
-            this.whitelistProvider = configuration.chatsWhitelistProvider;
-
-        if (configuration.timeinHoursProvider)
-            this.timeinHoursProvider = configuration.timeinHoursProvider;
-
-        if (configuration.isActiveProvider)
-            this.activeProvider = configuration.isActiveProvider;
-
-        return this;
-    }
-
-    /** Builds action */
-    build() {
-        return new ScheduledAction<TActionState>(
-            this.name,
-            this.handler,
-            {
-                chatsWhitelistProvider: this.whitelistProvider,
-                isActiveProvider: this.activeProvider,
-                timeinHoursProvider: this.timeinHoursProvider
-            },
-            this.cachedStateFactories,
-            this.stateConstructor
-        );
-    }
-}
-
-/**
- * Builder for `ScheduledAction` with state represented by default state (containing only last execution date).
- */
-export class ScheduledActionBuilder extends ScheduledActionBuilderWithState<ActionStateBase> {
-    /**
-     * Builder for `ScheduledAction` with state represented by default state (containing only last execution date).
-     */
-    constructor(name: string) {
-        super(name, () => new ActionStateBase());
-    }
-}

package/src/helpers/mapUtils.ts

@@ -1,28 +0,0 @@
-type KeyedReadonlyCollection<K, V> = { get: (key: K) => V | undefined };
-type KeyedWriteableCollection<K, V> = KeyedReadonlyCollection<K, V> & {
-    set: (key: K, value: V) => KeyedWriteableCollection<K, V>;
-};
-
-export function getOrSetIfNotExists<K, V>(
-    map: KeyedWriteableCollection<K, V>,
-    key: K,
-    fallback: V
-) {
-    const existingValue = map.get(key);
-    if (existingValue) return existingValue;
-
-    map.set(key, fallback);
-
-    return fallback;
-}
-
-export function getOrThrow<K, V>(
-    map: KeyedReadonlyCollection<K, V>,
-    key: K,
-    error: string = 'Key not found in collection'
-) {
-    const existingValue = map.get(key);
-    if (existingValue) return existingValue;
-
-    throw new Error(error);
-}

package/src/helpers/noop.ts

@@ -1,20 +0,0 @@
-import { BotResponse } from '../types/response';
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class Noop {
-    static readonly NoResponse: BotResponse[] = [];
-    static true(arg1: unknown) {
-        return true;
-    }
-    static false(arg1: unknown) {
-        return false;
-    }
-    static emptyString() {
-        return '';
-    }
-    static async call(arg1: unknown): Promise<void>;
-    static async call(arg1: unknown, arg2?: unknown) {
-        return Promise.resolve();
-    }
-}

package/src/helpers/objectFromEntries.ts

@@ -1,7 +0,0 @@
-export const typeSafeObjectFromEntries = <
-    const T extends ReadonlyArray<readonly [PropertyKey, unknown]>
->(
-    entries: T
-): { [K in T[number] as K[0]]: K[1] } => {
-    return Object.fromEntries(entries) as { [K in T[number] as K[0]]: K[1] };
-};

package/src/helpers/timeConvertions.ts

@@ -1,13 +0,0 @@
-import { Hours, Milliseconds, Seconds } from '../types/timeValues';
-
-export function secondsToMilliseconds(value: Seconds): Milliseconds {
-    return (value * 1000) as Milliseconds;
-}
-
-export function hoursToMilliseconds(value: Hours): Milliseconds {
-    return (value * 60 * 60 * 1000) as Milliseconds;
-}
-
-export function hoursToSeconds(value: Hours): Seconds {
-    return (value * 60 * 60) as Seconds;
-}

package/src/helpers/toArray.ts

@@ -1,3 +0,0 @@
-export function toArray<TType>(value: TType | TType[]) {
-    return Array.isArray(value) ? value : [value];
-}

package/src/helpers/traceFactory.ts

@@ -1,11 +0,0 @@
-import { TraceId } from '../types/trace';
-
-export function createTrace(
-    traceOwner: object | string,
-    botName: string,
-    traceName: string
-) {
-    return `${
-        typeof traceOwner == 'string' ? traceOwner : traceOwner.constructor.name
-    }:${botName}-${traceName}` as TraceId;
-}

package/src/index.ts

@@ -1,33 +0,0 @@
-export * from './main';
-export * from './helpers/builders/inlineQueryActionBuilder';
-export * from './helpers/builders/commandActionBuilder';
-export * from './helpers/builders/scheduledActionBuilder';
-export * from './types/actionState';
-export * from './entities/states/actionStateBase';
-export * from './types/messageTypes';
-export * from './helpers/timeConvertions';
-export * from './types/action';
-export * from './types/externalAliases';
-export * from './types/storage';
-export * from './types/scheduler';
-export { CommandAction } from './entities/actions/commandAction';
-export { InlineQueryAction } from './entities/actions/inlineQueryAction';
-export { ReplyCaptureAction } from './entities/actions/replyCaptureAction';
-export { ScheduledAction } from './entities/actions/scheduledAction';
-export { Hours, Milliseconds, Seconds } from './types/timeValues';
-export { ChatContext } from './entities/context/chatContext';
-export { InlineQueryContext } from './entities/context/inlineQueryContext';
-export { MessageContext } from './entities/context/messageContext';
-export { ReplyContext } from './entities/context/replyContext';
-export { ICaptureController } from './types/capture';
-export { ChatInfo } from './dtos/chatInfo';
-export { MessageInfo } from './dtos/messageInfo';
-export { UserInfo } from './dtos/userInfo';
-export {
-    BotEventType,
-    BotEventMap as BotEventArgumentsMap,
-    TypedEventEmitter,
-    Listener,
-    EachListener
-} from './types/events';
-export { TraceId } from './types/trace';

package/src/main.ts

@@ -1,76 +0,0 @@
-import { IStorageClient } from './types/storage';
-import { CommandAction } from './entities/actions/commandAction';
-import { ScheduledAction } from './entities/actions/scheduledAction';
-import { BotInstance } from './entities/botInstance';
-import { Seconds } from './types/timeValues';
-import { IScheduler } from './types/scheduler';
-import { InlineQueryAction } from './entities/actions/inlineQueryAction';
-import { IActionState } from './types/actionState';
-import { TypedEventEmitter } from './types/events';
-
-class BotOrchestrator {
-    bots: BotInstance[] = [];
-
-    /**
-     * Starts bot
-     */
-    async startBot(options: {
-        /** Bot name, used in logging */
-        name: string;
-        /** Function that provides the bot token. */
-        tokenProvider: () => Promise<string>;
-        actions: {
-            /** Collection of actions that will be executed as a response to message from used. Created using `CommandActionBuilder`.*/
-            commands: CommandAction<IActionState>[];
-            /** Collection of actions that will be executed on timer. Created using `ScheduledActionBuilder`.*/
-            scheduled: ScheduledAction<IActionState>[];
-            /** Collection of actions that will handle inline queries */
-            inlineQueries: InlineQueryAction[];
-        };
-        /** Object containing chat name and chat id pairs. Used for logging and execution of scheduled action. */
-        chats: Record<string, number>;
-        /** Storage path for default `JsonFileStorage` client. Will be used only if `storageClient` is not provided. If not provided, default value of `./storage/` will be used.*/
-        storagePath?: string;
-        /** Period of time between execution of scheduled actions. */
-        scheduledPeriod?: Seconds;
-        services?: {
-            /** Storage client for bot state storage. If not provided, default `JsonFileStorage` will be used. */
-            storageClient?: IStorageClient;
-            /** Scheduler client for bot scheduling. If not provided, default `NodeTimeoutScheduler` will be used. */
-            scheduler?: IScheduler;
-            /** Event emitter instance. If not provided, a default `TypedEventEmitter` will be created. Pass a `TypedEventEmitter<YourCustomEvents>` to support custom events. */
-            eventEmitter?: TypedEventEmitter<Record<string, unknown>>;
-        };
-    }) {
-        const token = await options.tokenProvider();
-
-        const bot = new BotInstance({
-            name: options.name,
-            actions: options.actions,
-            chats: options.chats,
-            services: {
-                storageClient: options.services?.storageClient,
-                scheduler: options.services?.scheduler,
-                eventEmitter: options.services?.eventEmitter
-            },
-            storagePath: options.storagePath
-        });
-
-        await bot.start(token, options.actions, options.scheduledPeriod);
-
-        this.bots.push(bot);
-
-        return bot;
-    }
-
-    /**
-     * Terminates all scheduled tasks, closes storage connections and stops all bots.
-     */
-    async stopBots() {
-        for (const bot of this.bots) {
-            await bot.stop();
-        }
-    }
-}
-
-export const botOrchestrator = new BotOrchestrator();

package/src/services/actionProcessingService.ts

@@ -1,125 +0,0 @@
-import { hoursToSeconds } from '../helpers/timeConvertions';
-import { Seconds, Milliseconds, Hours } from '../types/timeValues';
-import { IScheduler } from '../types/scheduler';
-import { IStorageClient } from '../types/storage';
-import { TelegramApiService } from './telegramApi';
-import { InlineQueryAction } from '../entities/actions/inlineQueryAction';
-import { IActionState } from '../types/actionState';
-import { CommandAction } from '../entities/actions/commandAction';
-import { ScheduledAction } from '../entities/actions/scheduledAction';
-import { buildHelpCommand } from '../builtin/helpAction';
-import { CommandActionProcessor } from './actionProcessors/commandActionProcessor';
-import { InlineQueryActionProcessor } from './actionProcessors/inlineQueryActionProcessor';
-import { ScheduledActionProcessor } from './actionProcessors/scheduledActionProcessor';
-import { TelegramBot } from '../types/externalAliases';
-import { Telegraf } from 'telegraf';
-import { TypedEventEmitter } from '../types/events';
-
-export class ActionProcessingService {
-    private readonly eventEmitter: TypedEventEmitter;
-    private readonly storage: IStorageClient;
-    private readonly commandProcessor: CommandActionProcessor;
-    private readonly scheduledProcessor: ScheduledActionProcessor;
-    private readonly inlineQueryProcessor: InlineQueryActionProcessor;
-
-    private readonly botName: string;
-
-    private telegramBot!: TelegramBot;
-
-    constructor(
-        botName: string,
-        chats: Record<string, number>,
-        storage: IStorageClient,
-        scheduler: IScheduler,
-        eventEmitter: TypedEventEmitter
-    ) {
-        this.storage = storage;
-        this.eventEmitter = eventEmitter;
-
-        this.commandProcessor = new CommandActionProcessor(
-            botName,
-            storage,
-            scheduler,
-            this.eventEmitter
-        );
-        this.scheduledProcessor = new ScheduledActionProcessor(
-            botName,
-            chats,
-            storage,
-            scheduler,
-            this.eventEmitter
-        );
-        this.inlineQueryProcessor = new InlineQueryActionProcessor(
-            botName,
-            storage,
-            scheduler,
-            this.eventEmitter
-        );
-
-        this.botName = botName;
-    }
-
-    async initialize(
-        token: string,
-        actions: {
-            commands: CommandAction<IActionState>[];
-            scheduled: ScheduledAction<IActionState>[];
-            inlineQueries: InlineQueryAction[];
-        },
-        scheduledPeriod?: Seconds
-    ) {
-        this.telegramBot = new Telegraf(token);
-        const api = new TelegramApiService(
-            this.botName,
-            this.telegramBot.telegram,
-            this.storage,
-            this.eventEmitter,
-            (capture, id, chatInfo, traceId) => {
-                this.commandProcessor.captureRegistrationCallback(
-                    capture,
-                    id,
-                    chatInfo,
-                    traceId
-                );
-            }
-        );
-
-        const botInfo = await this.telegramBot.telegram.getMe();
-        const commandActions =
-            actions.commands.length > 0 && botInfo.username
-                ? [
-                      buildHelpCommand(
-                          actions.commands
-                              .map((x) => x.readmeFactory(botInfo.username))
-                              .filter((x) => !!x),
-                          botInfo.username
-                      ),
-                      ...actions.commands
-                  ]
-                : [];
-
-        this.commandProcessor.initialize(
-            api,
-            this.telegramBot,
-            commandActions,
-            botInfo
-        );
-        this.inlineQueryProcessor.initialize(
-            api,
-            this.telegramBot,
-            actions.inlineQueries,
-            300 as Milliseconds
-        );
-        this.scheduledProcessor.initialize(
-            api,
-            actions.scheduled,
-            scheduledPeriod ?? hoursToSeconds(1 as Hours)
-        );
-
-        void this.telegramBot.launch();
-    }
-
-    stop() {
-        this.telegramBot.stop();
-    }
-}

package/src/services/actionProcessors/baseProcessor.ts

@@ -1,67 +0,0 @@
-import { IScheduler } from '../../types/scheduler';
-import { IStorageClient } from '../../types/storage';
-import { TelegramApiService } from '../telegramApi';
-import { IAction } from '../../types/action';
-import { BaseContextInternal } from '../../entities/context/baseContext';
-import { BotEventType, TypedEventEmitter } from '../../types/events';
-
-export abstract class BaseActionProcessor {
-    protected readonly storage: IStorageClient;
-    protected readonly scheduler: IScheduler;
-    protected readonly eventEmitter: TypedEventEmitter;
-
-    protected readonly botName: string;
-
-    protected api!: TelegramApiService;
-
-    constructor(
-        botName: string,
-        storage: IStorageClient,
-        scheduler: IScheduler,
-        eventEmitter: TypedEventEmitter
-    ) {
-        this.storage = storage;
-        this.scheduler = scheduler;
-        this.eventEmitter = eventEmitter;
-
-        this.botName = botName;
-    }
-
-    private defaultErrorHandler(
-        error: Error,
-        ctx: BaseContextInternal<IAction>
-    ) {
-        console.error(error);
-        this.eventEmitter.emit(BotEventType.error, {
-            error,
-            traceId: ctx.observability.traceId
-        });
-    }
-
-    initializeDependencies(api: TelegramApiService) {
-        this.api = api;
-    }
-
-    async executeAction<
-        TAction extends IAction,
-        TActionContext extends BaseContextInternal<TAction>
-    >(
-        action: TAction,
-        ctx: TActionContext,
-        errorHandler?: (error: Error, ctx: TActionContext) => void
-    ) {
-        try {
-            const responses = await action.exec(ctx);
-
-            this.api.enqueueBatchedResponses(responses);
-        } catch (e) {
-            const error = e as Error;
-
-            if (errorHandler) {
-                errorHandler(error, ctx);
-            } else {
-                this.defaultErrorHandler(error, ctx);
-            }
-        }
-    }
-}