chz-telegram-bot 0.7.13 → 0.7.15

package/src/dtos/userInfo.ts

@@ -1,8 +0,0 @@
-export class UserInfo {
-    constructor(
-        /** Id of a user that sent a message that triggered this action. */
-        readonly id: number,
-        /** Name of a user that sent a message that triggered this action. */
-        readonly name: string
-    ) {}
-}

package/src/entities/actions/commandAction.ts

@@ -1,275 +0,0 @@
-import moment from 'moment';
-import { CommandHandler } from '../../types/handlers';
-import { CommandCondition } from '../../types/commandCondition';
-import { secondsToMilliseconds } from '../../helpers/timeConvertions';
-import { toArray } from '../../helpers/toArray';
-import { IActionState } from '../../types/actionState';
-import { IActionWithState, ActionKey } from '../../types/action';
-import { CommandTriggerCheckResult } from '../../dtos/commandTriggerCheckResult';
-import { MessageContextInternal } from '../context/messageContext';
-import { CommandTrigger } from '../../types/commandTrigger';
-import { Noop } from '../../helpers/noop';
-import { MessageType } from '../../types/messageTypes';
-import { Sema as Semaphore } from 'async-sema';
-import { getOrSetIfNotExists } from '../../helpers/mapUtils';
-import { CooldownInfo } from '../../dtos/cooldownInfo';
-import { TextMessage } from '../../dtos/responses/textMessage';
-import { ReplyInfo } from '../../dtos/replyInfo';
-import { Seconds } from '../../types/timeValues';
-import { CommandActionPropertyProvider } from '../../types/propertyProvider';
-import { CommandActionProviders } from '../../dtos/propertyProviderSets';
-import { BotResponse } from '../../types/response';
-import { BotEventType } from '../../types/events';
-
-export class CommandAction<
-    TActionState extends IActionState
-> implements IActionWithState<TActionState> {
-    private readonly cooldownInfoProvider: CommandActionPropertyProvider<CooldownInfo>;
-    private readonly isActiveProvider: CommandActionPropertyProvider<boolean>;
-    private readonly chatsBlacklistProvider: CommandActionPropertyProvider<
-        number[]
-    >;
-    private readonly chatsWhitelistProvider: CommandActionPropertyProvider<
-        number[]
-    >;
-    private readonly usersWhitelistProvider: CommandActionPropertyProvider<
-        number[]
-    >;
-
-    readonly key: ActionKey;
-    readonly name: string;
-    readonly ratelimitSemaphores = new Map<number, Semaphore>();
-    readonly maxAllowedSimultaniousExecutions: number;
-
-    readonly triggers: CommandTrigger[];
-
-    readonly handler: CommandHandler<TActionState>;
-    readonly condition: CommandCondition<TActionState>;
-    readonly stateConstructor: () => TActionState;
-    readonly readmeFactory: (botName: string) => string;
-
-    private lastCustomCooldown: Seconds | undefined;
-
-    constructor(
-        trigger: CommandTrigger | CommandTrigger[],
-        handler: CommandHandler<TActionState>,
-        name: string,
-        providers: CommandActionProviders,
-        condition: CommandCondition<TActionState>,
-        stateConstructor: () => TActionState,
-        readmeFactory: (botName: string) => string
-    ) {
-        this.triggers = toArray(trigger);
-        this.name = name;
-
-        this.cooldownInfoProvider = providers.cooldownProvider;
-        this.isActiveProvider = providers.isActiveProvider;
-        this.chatsBlacklistProvider = providers.chatsBlacklistProvider;
-        this.chatsWhitelistProvider = providers.chatsWhitelistProvider;
-        this.usersWhitelistProvider = providers.usersWhitelistProvider;
-
-        this.handler = handler;
-        this.condition = condition;
-        this.stateConstructor = stateConstructor;
-        this.readmeFactory = readmeFactory;
-
-        this.maxAllowedSimultaniousExecutions =
-            providers.maxAllowedSimultaniousExecutions;
-
-        this.key = `command:${this.name.replace('.', '-')}` as ActionKey;
-    }
-
-    async exec(
-        ctx: MessageContextInternal<TActionState>
-    ): Promise<BotResponse[]> {
-        let lock: Semaphore | undefined;
-        if (this.maxAllowedSimultaniousExecutions != 0) {
-            lock = getOrSetIfNotExists(
-                this.ratelimitSemaphores,
-                ctx.chatInfo.id,
-                new Semaphore(this.maxAllowedSimultaniousExecutions)
-            );
-
-            await lock.acquire();
-        }
-
-        try {
-            const state = ctx.storage.getActionState<TActionState>(
-                this,
-                ctx.chatInfo.id
-            );
-
-            const { shouldExecute, matchResults, skipCooldown, reason } =
-                this.triggers
-                    .map((x) => this.checkIfShouldBeExecuted(ctx, x, state))
-                    .reduce(
-                        (acc, curr) => acc.mergeWith(curr),
-                        CommandTriggerCheckResult.DoNotTrigger('Other')
-                    );
-
-            if (!shouldExecute) {
-                if (reason == 'OnCooldown') {
-                    const cooldownMessage =
-                        this.cooldownInfoProvider(ctx).message;
-
-                    return cooldownMessage
-                        ? [
-                              new TextMessage(
-                                  cooldownMessage,
-                                  ctx.chatInfo,
-                                  ctx.observability.traceId,
-                                  this,
-                                  new ReplyInfo(ctx.messageInfo.id)
-                              )
-                          ]
-                        : Noop.NoResponse;
-                }
-
-                return Noop.NoResponse;
-            }
-
-            ctx.observability.eventEmitter.emit(
-                BotEventType.commandActionExecuting,
-                {
-                    action: this,
-                    ctx,
-                    state,
-                    traceId: ctx.observability.traceId
-                }
-            );
-            ctx.matchResults = matchResults;
-
-            await this.handler(ctx, state);
-
-            if (skipCooldown) {
-                ctx.startCooldown = false;
-            }
-
-            if (ctx.startCooldown) {
-                this.lastCustomCooldown = ctx.customCooldown;
-
-                state.lastExecutedDate = moment().valueOf();
-            }
-
-            await ctx.storage.saveActionExecutionResult(
-                this,
-                ctx.chatInfo.id,
-                state
-            );
-
-            ctx.observability.eventEmitter.emit(
-                BotEventType.commandActionExecuted,
-                {
-                    action: this,
-                    ctx,
-                    state,
-                    traceId: ctx.observability.traceId
-                }
-            );
-            return ctx.responses;
-        } finally {
-            lock?.release();
-        }
-    }
-
-    private checkIfShouldBeExecuted(
-        ctx: MessageContextInternal<TActionState>,
-        trigger: CommandTrigger,
-        state: TActionState
-    ) {
-        if (!this.isActiveProvider(ctx))
-            return CommandTriggerCheckResult.DontTriggerAndSkipCooldown(
-                'ActionDisabled'
-            );
-
-        const chatsBlacklist = this.chatsBlacklistProvider(ctx);
-        const chatsWhitelist = this.chatsWhitelistProvider(ctx);
-
-        const isChatInBlacklist = chatsBlacklist.includes(ctx.chatInfo.id);
-        const isChatInWhitelist =
-            chatsWhitelist.length == 0 ||
-            chatsWhitelist.includes(ctx.chatInfo.id);
-
-        if (isChatInBlacklist || !isChatInWhitelist)
-            return CommandTriggerCheckResult.DontTriggerAndSkipCooldown(
-                'ChatForbidden'
-            );
-
-        const triggerCheckResult = this.checkTrigger(ctx, trigger);
-
-        if (!triggerCheckResult.shouldExecute) return triggerCheckResult;
-
-        if (!ctx.userInfo.id)
-            return CommandTriggerCheckResult.DontTriggerAndSkipCooldown(
-                'UserIdMissing'
-            );
-
-        const usersWhitelist = this.usersWhitelistProvider(ctx);
-        const isUserAllowed =
-            usersWhitelist.length == 0 ||
-            usersWhitelist.includes(ctx.userInfo.id);
-
-        if (!isUserAllowed)
-            return CommandTriggerCheckResult.DontTriggerAndSkipCooldown(
-                'UserForbidden'
-            );
-
-        const lastExecutedDate = moment(state.lastExecutedDate);
-        const cooldownInMilliseconds = secondsToMilliseconds(
-            this.lastCustomCooldown ?? this.cooldownInfoProvider(ctx).cooldown
-        );
-        const onCooldown =
-            moment().diff(lastExecutedDate) < cooldownInMilliseconds;
-
-        if (onCooldown)
-            return CommandTriggerCheckResult.DoNotTrigger('OnCooldown');
-
-        const isCustomConditionMet = this.condition(ctx, state);
-        if (!isCustomConditionMet)
-            return CommandTriggerCheckResult.DontTriggerAndSkipCooldown(
-                'CustomConditionNotMet'
-            );
-
-        return triggerCheckResult;
-    }
-
-    private checkTrigger(
-        ctx: MessageContextInternal<TActionState>,
-        trigger: CommandTrigger
-    ) {
-        if (trigger == MessageType.Any || trigger == ctx.messageInfo.type)
-            return CommandTriggerCheckResult.Trigger();
-
-        if (typeof trigger == 'string')
-            return ctx.messageInfo.text.toLowerCase() == trigger.toLowerCase()
-                ? CommandTriggerCheckResult.Trigger()
-                : CommandTriggerCheckResult.DoNotTrigger('TriggerNotSatisfied');
-
-        const matchResults: RegExpExecArray[] = [];
-
-        trigger.lastIndex = 0;
-
-        const execResult = trigger.exec(ctx.messageInfo.text);
-        if (execResult != null) {
-            let regexMatchLimit = 100;
-            matchResults.push(execResult);
-
-            if (trigger.global) {
-                while (regexMatchLimit > 0) {
-                    const nextResult = trigger.exec(ctx.messageInfo.text);
-
-                    if (nextResult == null) break;
-
-                    matchResults.push(nextResult);
-                    regexMatchLimit -= 1;
-                }
-            }
-        }
-
-        return new CommandTriggerCheckResult(
-            matchResults.length > 0,
-            matchResults,
-            false
-        );
-    }
-}

package/src/entities/actions/inlineQueryAction.ts

@@ -1,83 +0,0 @@
-import { Noop } from '../../helpers/noop';
-import { ActionKey, IAction } from '../../types/action';
-import { InlineQueryContextInternal } from '../context/inlineQueryContext';
-import { InlineQueryHandler } from '../../types/handlers';
-import { InlineActionPropertyProvider } from '../../types/propertyProvider';
-import { BotEventType } from '../../types/events';
-import { InlineQueryResponse } from '../../dtos/responses/inlineQueryResponse';
-
-export class InlineQueryAction implements IAction {
-    readonly key: ActionKey;
-    readonly isActiveProvider: InlineActionPropertyProvider<boolean>;
-    readonly handler: InlineQueryHandler;
-    readonly name: string;
-    readonly pattern: RegExp;
-
-    constructor(
-        handler: InlineQueryHandler,
-        name: string,
-        activeProvider: InlineActionPropertyProvider<boolean>,
-        pattern: RegExp
-    ) {
-        this.handler = handler;
-        this.name = name;
-        this.isActiveProvider = activeProvider;
-        this.pattern = pattern;
-
-        this.key = `inline:${this.name.replace('.', '-')}` as ActionKey;
-    }
-
-    async exec(ctx: InlineQueryContextInternal) {
-        if (!this.isActiveProvider(ctx)) return Noop.NoResponse;
-
-        const matchResults: RegExpExecArray[] = [];
-
-        this.pattern.lastIndex = 0;
-
-        const execResult = this.pattern.exec(ctx.queryText);
-        if (execResult != null) {
-            let regexMatchLimit = 100;
-            matchResults.push(execResult);
-
-            if (this.pattern.global) {
-                while (regexMatchLimit > 0) {
-                    const nextResult = this.pattern.exec(ctx.queryText);
-
-                    if (nextResult == null) break;
-
-                    matchResults.push(nextResult);
-                    regexMatchLimit -= 1;
-                }
-            }
-        }
-
-        if (matchResults.length == 0) return Noop.NoResponse;
-
-        ctx.matchResults = matchResults;
-
-        ctx.observability.eventEmitter.emit(
-            BotEventType.inlineActionExecuting,
-            {
-                action: this,
-                ctx,
-                traceId: ctx.observability.traceId
-            }
-        );
-
-        await this.handler(ctx);
-
-        ctx.observability.eventEmitter.emit(BotEventType.inlineActionExecuted, {
-            action: this,
-            ctx,
-            traceId: ctx.observability.traceId
-        });
-        return [
-            new InlineQueryResponse(
-                ctx.queryResults,
-                ctx.queryId,
-                ctx.observability.traceId,
-                ctx.action
-            )
-        ];
-    }
-}

package/src/entities/actions/replyCaptureAction.ts

@@ -1,110 +0,0 @@
-import { CommandTriggerCheckResult } from '../../dtos/commandTriggerCheckResult';
-import { Noop } from '../../helpers/noop';
-import { IActionState } from '../../types/actionState';
-import { CommandTrigger } from '../../types/commandTrigger';
-import { ActionKey, IAction } from '../../types/action';
-import { ReplyContextInternal } from '../context/replyContext';
-import { BotEventType } from '../../types/events';
-
-export class ReplyCaptureAction<
-    TParentActionState extends IActionState
-> implements IAction {
-    readonly parentMessageId: number;
-    readonly key: ActionKey;
-    readonly handler: (
-        replyContext: ReplyContextInternal<TParentActionState>
-    ) => Promise<void>;
-    readonly triggers: CommandTrigger[];
-    readonly abortController: AbortController;
-
-    constructor(
-        parentMessageId: number,
-        parentAction: IAction,
-        handler: (
-            replyContext: ReplyContextInternal<TParentActionState>
-        ) => Promise<void>,
-        triggers: CommandTrigger[],
-        abortController: AbortController
-    ) {
-        this.parentMessageId = parentMessageId;
-        this.handler = handler;
-        this.triggers = triggers;
-        this.abortController = abortController;
-
-        this.key = `capture:${parentAction.key}:${Math.random()
-            .toString()
-            .replace('.', '')}` as ActionKey;
-    }
-
-    async exec(ctx: ReplyContextInternal<TParentActionState>) {
-        const { shouldExecute, matchResults } = this.triggers
-            .map((x) => this.checkIfShouldBeExecuted(ctx, x))
-            .reduce(
-                (acc, curr) => acc.mergeWith(curr),
-                CommandTriggerCheckResult.DoNotTrigger('Other')
-            );
-
-        if (!shouldExecute) return Noop.NoResponse;
-
-        ctx.observability.eventEmitter.emit(BotEventType.replyActionExecuting, {
-            action: this,
-            ctx,
-            traceId: ctx.observability.traceId
-        });
-        ctx.matchResults = matchResults;
-
-        await this.handler(ctx);
-
-        ctx.observability.eventEmitter.emit(BotEventType.replyActionExecuted, {
-            action: this,
-            ctx,
-            traceId: ctx.observability.traceId
-        });
-        return ctx.responses;
-    }
-
-    private checkIfShouldBeExecuted(
-        ctx: ReplyContextInternal<TParentActionState>,
-        trigger: CommandTrigger
-    ) {
-        if (ctx.replyMessageId != this.parentMessageId)
-            return CommandTriggerCheckResult.DoNotTrigger(
-                'TriggerNotSatisfied'
-            );
-
-        if (trigger == ctx.messageInfo.type)
-            return CommandTriggerCheckResult.Trigger();
-
-        if (typeof trigger == 'string')
-            return ctx.messageInfo.text.toLowerCase() == trigger.toLowerCase()
-                ? CommandTriggerCheckResult.Trigger()
-                : CommandTriggerCheckResult.DoNotTrigger('TriggerNotSatisfied');
-
-        const matchResults: RegExpExecArray[] = [];
-
-        trigger.lastIndex = 0;
-
-        const execResult = trigger.exec(ctx.messageInfo.text);
-        if (execResult != null) {
-            let regexMatchLimit = 100;
-            matchResults.push(execResult);
-
-            if (trigger.global) {
-                while (regexMatchLimit > 0) {
-                    const nextResult = trigger.exec(ctx.messageInfo.text);
-
-                    if (nextResult == null) break;
-
-                    matchResults.push(nextResult);
-                    regexMatchLimit -= 1;
-                }
-            }
-        }
-
-        return new CommandTriggerCheckResult(
-            matchResults.length > 0,
-            matchResults,
-            false
-        );
-    }
-}

package/src/entities/actions/scheduledAction.ts

@@ -1,182 +0,0 @@
-import moment from 'moment';
-import { Sema as Semaphore } from 'async-sema';
-import { ScheduledHandler } from '../../types/handlers';
-import { hoursToMilliseconds } from '../../helpers/timeConvertions';
-import { HoursOfDay } from '../../types/timeValues';
-import { IActionState } from '../../types/actionState';
-import { IActionWithState, ActionKey } from '../../types/action';
-import { CachedStateFactory } from '../cachedStateFactory';
-import { ChatContextInternal } from '../context/chatContext';
-import { Noop } from '../../helpers/noop';
-import { getOrSetIfNotExists, getOrThrow } from '../../helpers/mapUtils';
-import { ScheduledActionPropertyProvider } from '../../types/propertyProvider';
-import { ScheduledActionProviders } from '../../dtos/propertyProviderSets';
-import { BotEventType } from '../../types/events';
-
-export class ScheduledAction<
-    TActionState extends IActionState
-> implements IActionWithState<TActionState> {
-    static readonly locks = new Map<string, Semaphore>();
-
-    readonly name: string;
-    readonly key: ActionKey;
-
-    private readonly timeinHoursProvider: ScheduledActionPropertyProvider<HoursOfDay>;
-    private readonly activeProvider: ScheduledActionPropertyProvider<boolean>;
-    private readonly chatsWhitelistProvider: ScheduledActionPropertyProvider<
-        number[]
-    >;
-
-    readonly cachedState = new Map<string, unknown>();
-    readonly stateConstructor: () => TActionState;
-    readonly cachedStateFactories: Map<string, CachedStateFactory>;
-    readonly handler: ScheduledHandler<TActionState>;
-
-    constructor(
-        name: string,
-        handler: ScheduledHandler<TActionState>,
-        providers: ScheduledActionProviders,
-        cachedStateFactories: Map<string, CachedStateFactory>,
-        stateConstructor: () => TActionState
-    ) {
-        this.name = name;
-        this.key = `scheduled:${this.name.replace('.', '-')}` as ActionKey;
-
-        this.timeinHoursProvider = providers.timeinHoursProvider;
-        this.activeProvider = providers.isActiveProvider;
-        this.chatsWhitelistProvider = providers.chatsWhitelistProvider;
-
-        this.cachedStateFactories = cachedStateFactories;
-        this.stateConstructor = stateConstructor;
-        this.handler = handler;
-    }
-
-    async exec(ctx: ChatContextInternal<TActionState>) {
-        if (
-            !this.activeProvider(ctx) ||
-            !this.chatsWhitelistProvider(ctx).includes(ctx.chatInfo.id)
-        )
-            return Noop.NoResponse;
-
-        const state = ctx.storage.getActionState<TActionState>(
-            this,
-            ctx.chatInfo.id
-        );
-
-        const isAllowedToTrigger = this.checkIfShouldBeExecuted(state, ctx);
-        if (!isAllowedToTrigger) return Noop.NoResponse;
-
-        ctx.observability.eventEmitter.emit(
-            BotEventType.scheduledActionExecuting,
-            {
-                action: this,
-                ctx,
-                state,
-                traceId: ctx.observability.traceId
-            }
-        );
-
-        await this.handler(
-            ctx,
-            <TResult>(key: string) => this.getCachedValue<TResult>(key, ctx),
-            state
-        );
-
-        state.lastExecutedDate = moment().valueOf();
-
-        await ctx.storage.saveActionExecutionResult(
-            this,
-            ctx.chatInfo.id,
-            state
-        );
-
-        ctx.observability.eventEmitter.emit(
-            BotEventType.scheduledActionExecuted,
-            {
-                action: this,
-                ctx,
-                state,
-                traceId: ctx.observability.traceId
-            }
-        );
-        return ctx.responses;
-    }
-
-    private async getCachedValue<TResult>(
-        key: string,
-        ctx: ChatContextInternal<TActionState>
-    ): Promise<TResult> {
-        const cachedItemFactory = getOrThrow(
-            this.cachedStateFactories,
-            key,
-            `No shared cache was set up for the key [${key}] in action '${this.name}'`
-        );
-
-        const semaphoreKey = `${this.key}_cached:${key}`;
-        const semaphore = getOrSetIfNotExists(
-            ScheduledAction.locks,
-            semaphoreKey,
-            new Semaphore(1)
-        );
-
-        await semaphore.acquire();
-
-        try {
-            if (this.cachedState.has(key)) {
-                return this.cachedState.get(key) as TResult;
-            }
-
-            ctx.observability.eventEmitter.emit(
-                BotEventType.scheduledActionCacheValueCreating,
-                {
-                    action: this,
-                    ctx,
-                    key,
-                    traceId: ctx.observability.traceId
-                }
-            );
-            const value = await cachedItemFactory.getValue();
-
-            this.cachedState.set(key, value);
-
-            ctx.scheduler.createOnetimeTask(
-                `Drop cached value [${this.name} : ${key}]`,
-                () => this.cachedState.delete(key),
-                hoursToMilliseconds(
-                    cachedItemFactory.invalidationTimeoutInHours
-                ),
-                ctx.botName
-            );
-
-            return value as TResult;
-        } finally {
-            ctx.observability.eventEmitter.emit(
-                BotEventType.scheduledActionCacheValueReturned,
-                {
-                    action: this,
-                    ctx,
-                    key,
-                    traceId: ctx.observability.traceId
-                }
-            );
-            semaphore.release();
-        }
-    }
-
-    private checkIfShouldBeExecuted(
-        state: IActionState,
-        ctx: ChatContextInternal<TActionState>
-    ): boolean {
-        const startOfToday = moment().startOf('day').valueOf();
-        const lastExecutedDate = moment(state.lastExecutedDate);
-        const currentTime = moment();
-        const scheduledTime = moment()
-            .startOf('day')
-            .add(this.timeinHoursProvider(ctx), 'hours');
-
-        const isAllowedToTrigger = currentTime.isSameOrAfter(scheduledTime);
-        const hasTriggeredToday = lastExecutedDate.isAfter(startOfToday);
-
-        return isAllowedToTrigger && !hasTriggeredToday;
-    }
-}