chz-telegram-bot 0.1.3 → 0.1.4

package/entities/actions/commandAction.ts

@@ -5,7 +5,7 @@ import { Seconds } from '../../types/timeValues';
 import { secondsToMilliseconds } from '../../helpers/timeConvertions';
 import { toArray } from '../../helpers/toArray';
 import { IActionState } from '../../types/actionState';
-import { IActionWithState, ActionKey } from '../../types/actionWithState';
+import { IActionWithState, ActionKey } from '../../types/statefulAction';
 import { CommandTriggerCheckResult } from '../../dtos/commandTriggerCheckResult';
 import { MessageContext } from '../context/messageContext';
 import { CommandTrigger } from '../../types/commandTrigger';

package/entities/actions/inlineQueryAction.ts

@@ -0,0 +1,68 @@
+import { Noop } from '../../helpers/noop';
+import { ActionKey } from '../../types/statefulAction';
+import { InlineQueryContext } from '../context/inlineQueryContext';
+import { InlineQueryHandler } from '../../types/handlers';
+import { IActionWithoutState } from '../../types/statelessAction';
+
+export class InlineQueryAction implements IActionWithoutState {
+    readonly key: ActionKey;
+    readonly active: boolean;
+    readonly handler: InlineQueryHandler;
+    readonly name: string;
+    readonly pattern: RegExp;
+
+    constructor(
+        handler: InlineQueryHandler,
+        name: string,
+        active: boolean,
+        pattern: RegExp
+    ) {
+        this.handler = handler;
+        this.name = name;
+        this.active = active;
+        this.pattern = pattern;
+
+        this.key = `inline:${this.name.replace('.', '-')}` as ActionKey;
+    }
+
+    async exec(ctx: InlineQueryContext) {
+        if (!ctx.isInitialized)
+            throw new Error(
+                `Context for ${this.key} is not initialized or already consumed`
+            );
+
+        if (!this.active) return Noop.NoResponse;
+
+        const matchResults: RegExpExecArray[] = [];
+
+        this.pattern.lastIndex = 0;
+
+        const execResult = this.pattern.exec(ctx.queryText);
+        if (execResult != null) {
+            matchResults.push(execResult);
+
+            if (this.pattern.global) {
+                while (true) {
+                    const nextResult = this.pattern.exec(ctx.queryText);
+                    if (nextResult == null) break;
+                    matchResults.push(nextResult);
+                }
+            }
+        }
+
+        if (matchResults.length == 0) return Noop.NoResponse;
+
+        ctx.matchResults = matchResults;
+
+        ctx.logger.logWithTraceId(
+            ctx.botName,
+            ctx.traceId,
+            'Unknown',
+            ` - Executing [${this.name}]`
+        );
+
+        await this.handler(ctx);
+
+        return ctx.responses;
+    }
+}

package/entities/actions/scheduledAction.ts

@@ -4,7 +4,7 @@ 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/actionWithState';
+import { IActionWithState, ActionKey } from '../../types/statefulAction';
 import { CachedStateFactory } from '../cachedStateFactory';
 import { ChatContext } from '../context/chatContext';
 import { Noop } from '../../helpers/noop';

package/entities/botInstance.ts

@@ -20,6 +20,9 @@ import { ILogger } from '../types/logger';
 import { IScheduler } from '../types/scheduler';
 import { NodeTimeoutScheduler } from '../services/nodeTimeoutScheduler';
 import { createTrace } from '../helpers/traceFactory';
+import { InlineQueryAction } from './actions/inlineQueryAction';
+import { IncomingInlineQuery } from '../dtos/incomingQuery';
+import { InlineQueryContext } from './context/inlineQueryContext';
 
 export class BotInstance {
     private readonly api: TelegramApiService;
@@ -31,13 +34,17 @@ export class BotInstance {
     private readonly telegraf: Telegraf;
     private readonly commands: CommandAction<IActionState>[];
     private readonly scheduled: ScheduledAction<IActionState>[];
+    private readonly inlineQueries: InlineQueryAction[];
     private readonly chats: Record<string, number>;
 
     constructor(options: {
         name: string;
         token: string;
-        commands: CommandAction<IActionState>[];
-        scheduled: ScheduledAction<IActionState>[];
+        actions: {
+            commands: CommandAction<IActionState>[];
+            scheduled: ScheduledAction<IActionState>[];
+            inlineQueries: InlineQueryAction[];
+        };
         chats: Record<string, number>;
         storagePath?: string;
         scheduledPeriod?: Seconds;
@@ -49,8 +56,9 @@ export class BotInstance {
         };
     }) {
         this.name = options.name;
-        this.commands = options.commands;
-        this.scheduled = options.scheduled;
+        this.commands = options.actions.commands;
+        this.scheduled = options.actions.scheduled;
+        this.inlineQueries = options.actions.inlineQueries;
         this.chats = options.chats;
 
         const actions = [...this.commands, ...this.scheduled];
@@ -72,6 +80,7 @@ export class BotInstance {
         this.initializeMessageProcessing(
             options.verboseLoggingForIncomingMessage ?? false
         );
+        this.initializeInlineQueryProcessing(500 as Milliseconds);
         this.initializeScheduledProcessing(
             options.scheduledPeriod ?? hoursToSeconds(1 as Hours)
         );
@@ -130,6 +139,79 @@ export class BotInstance {
             );
         }
     }
+
+    private initializeInlineQueryProcessing(period: Milliseconds) {
+        let pendingInlineQueries: IncomingInlineQuery[] = [];
+
+        if (this.inlineQueries.length > 0) {
+            this.telegraf.on('inline_query', async (ctx) => {
+                const query = new IncomingInlineQuery(
+                    ctx.inlineQuery.id,
+                    ctx.inlineQuery.query,
+                    ctx.inlineQuery.from.id,
+                    createTrace('InlineQuery', this.name, ctx.inlineQuery.id)
+                );
+
+                this.logger.logWithTraceId(
+                    this.name,
+                    query.traceId,
+                    'Query',
+                    `${ctx.inlineQuery.from.username} (${ctx.inlineQuery.from.id}): Query for ${ctx.inlineQuery.query}`
+                );
+
+                pendingInlineQueries = pendingInlineQueries.filter(
+                    (q) => q.userId != query.userId
+                );
+
+                pendingInlineQueries.push(query);
+            });
+
+            this.scheduler.createTask(
+                'InlineQueryProcessing',
+                async () => {
+                    const ctx = new InlineQueryContext(
+                        this.storage,
+                        this.logger,
+                        this.scheduler
+                    );
+
+                    for (const inlineQuery of pendingInlineQueries) {
+                        for (const inlineQueryAction of this.inlineQueries) {
+                            ctx.initializeContext(
+                                inlineQuery.query,
+                                inlineQuery.queryId,
+                                this.name,
+                                inlineQueryAction,
+                                inlineQuery.traceId
+                            );
+
+                            try {
+                                const responses = await inlineQueryAction.exec(
+                                    ctx
+                                );
+                                this.api.enqueueBatchedResponses(responses);
+                                ctx.isInitialized = false;
+                            } catch (error) {
+                                this.logger.errorWithTraceId(
+                                    ctx.botName,
+                                    ctx.traceId,
+                                    'Unknown',
+                                    error,
+                                    ctx
+                                );
+                            }
+                        }
+                    }
+
+                    this.api.flushResponses();
+                },
+                period,
+                false,
+                this.name
+            );
+        }
+    }
+
     private initializeMessageProcessing(
         verboseLoggingForIncomingMessage: boolean
     ) {

package/entities/context/chatContext.ts

@@ -8,7 +8,7 @@ import {
     MessageSendingOptions,
     TextMessageSendingOptions
 } from '../../types/messageSendingOptions';
-import { IActionWithState } from '../../types/actionWithState';
+import { IActionWithState } from '../../types/statefulAction';
 import { IActionState } from '../../types/actionState';
 import { BotResponse } from '../../types/response';
 import { Milliseconds } from '../../types/timeValues';
@@ -25,11 +25,11 @@ export class ChatContext<TActionState extends IActionState> {
     protected action!: IActionWithState<TActionState>;
 
     /** Storage client instance for the bot executing this action. */
-    readonly storage!: IStorageClient;
+    readonly storage: IStorageClient;
     /** Logger instance for the bot executing this action */
-    readonly logger!: ILogger;
+    readonly logger: ILogger;
     /** Scheduler instance for the bot executing this action */
-    readonly scheduler!: IScheduler;
+    readonly scheduler: IScheduler;
 
     /** Trace id of a action execution. */
     traceId!: TraceId;

package/entities/context/inlineQueryContext.ts

@@ -0,0 +1,83 @@
+import { InlineQueryResult } from 'telegraf/types';
+import { ILogger } from '../../types/logger';
+import { BotResponse } from '../../types/response';
+import { IScheduler } from '../../types/scheduler';
+import { IStorageClient } from '../../types/storage';
+import { TraceId } from '../../types/trace';
+import { InlineQueryAction } from '../actions/inlineQueryAction';
+import { InlineQueryResponse } from '../../dtos/responses/inlineQueryResponse';
+
+export class InlineQueryContext {
+    private action!: InlineQueryAction;
+    private queryResults: InlineQueryResult[] = [];
+
+    /** Storage client instance for the bot executing this action. */
+    readonly storage: IStorageClient;
+    /** Logger instance for the bot executing this action */
+    readonly logger: ILogger;
+    /** Scheduler instance for the bot executing this action */
+    readonly scheduler: IScheduler;
+
+    /** Trace id of a action execution. */
+    traceId!: TraceId;
+    /** Name of a bot that executes this action. */
+    botName!: string;
+
+    /** Ordered collection of responses to be processed  */
+    get responses(): BotResponse[] {
+        return [
+            new InlineQueryResponse(
+                this.queryResults,
+                this.queryId,
+                this.traceId,
+                this.action
+            )
+        ];
+    }
+    /** Inline query text */
+    queryText!: string;
+    /** Internal query id */
+    queryId!: string;
+    /** Collection of Regexp match results on a message that triggered this action. Will be empty if trigger is not a Regexp. */
+    matchResults: RegExpMatchArray[] = [];
+
+    isInitialized = false;
+
+    constructor(
+        storage: IStorageClient,
+        logger: ILogger,
+        scheduler: IScheduler
+    ) {
+        this.storage = storage;
+        this.logger = logger;
+        this.scheduler = scheduler;
+    }
+
+    initializeContext(
+        queryText: string,
+        queryId: string,
+        botName: string,
+        action: InlineQueryAction,
+        traceId: TraceId
+    ) {
+        this.queryText = queryText;
+        this.queryId = queryId;
+        this.botName = botName;
+        this.action = action;
+        this.traceId = traceId;
+
+        this.isInitialized = true;
+        this.queryResults = [];
+        this.matchResults = [];
+
+        return this;
+    }
+
+    /**
+     * This result will be shown to user as a response to inline query.
+     * @param queryResult Inline query result to be shown to user.
+     */
+    showInlineQueryResult(queryResult: InlineQueryResult) {
+        this.queryResults.push(queryResult);
+    }
+}

package/entities/context/messageContext.ts

@@ -13,7 +13,7 @@ import {
     MessageSendingOptions,
     TextMessageSendingOptions
 } from '../../types/messageSendingOptions';
-import { IActionWithState, ActionKey } from '../../types/actionWithState';
+import { IActionWithState, ActionKey } from '../../types/statefulAction';
 import { MessageTypeValue } from '../../types/messageTypes';
 import { ILogger } from '../../types/logger';
 import { IScheduler } from '../../types/scheduler';

package/helpers/builders/inlineQueryActionBuilder.ts

@@ -0,0 +1,62 @@
+import { InlineQueryHandler } from '../../types/handlers';
+import { Seconds } from '../../types/timeValues';
+import { Noop } from '../noop';
+import { InlineQueryAction } from '../../entities/actions/inlineQueryAction';
+
+/**
+ * Builder for `InlineQueryAction`
+ */
+export class InlineQueryActionBuilder {
+    name: string;
+    pattern: RegExp = /.+/gi;
+
+    active = true;
+    cooldownSeconds: Seconds = 0 as Seconds;
+    blacklist: number[] = [];
+    allowedUsers: number[] = [];
+    handler: InlineQueryHandler = Noop.call;
+
+    /**
+     * Builder for `InlineQueryAction`
+     * @param name Action name, will be used for logging and storage
+     */
+    constructor(name: string) {
+        this.name = name;
+    }
+
+    /**
+     * Defines action pattern to check if action should be executed, if not setup, check will default to true
+     * @param trigger RegExp to check
+     */
+    on(pattern: RegExp) {
+        this.pattern = pattern;
+
+        return this;
+    }
+
+    /** Defines action logic itself, will be executed.
+     * @param handler Callback that will be called
+     */
+    do(handler: InlineQueryHandler) {
+        this.handler = handler;
+
+        return this;
+    }
+
+    /** If called during building, action is marked as disabled and never checked. */
+    disabled() {
+        this.active = false;
+
+        return this;
+    }
+
+    /** Builds action */
+    build() {
+        return new InlineQueryAction(
+            this.handler,
+            this.name,
+            this.active,
+            this.pattern
+        );
+    }
+}

package/helpers/noop.ts

@@ -9,6 +9,8 @@ export class Noop {
     static false<T1>(arg1: T1) {
         return false;
     }
+
+    static async call<T1>(arg1: T1): Promise<void>;
     static async call<T1, T2>(arg1: T1, arg2: T2): Promise<void>;
-    static async call<T1>(arg1: T1) {}
+    static async call(arg1: unknown, arg2?: unknown) {}
 }

package/helpers/traceFactory.ts

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

package/index.ts

@@ -1,4 +1,4 @@
-export { startBot, stopBots } from './main';
+export { botOrchestrator } from './main';
 export { CommandActionBuilder } from './helpers/builders/commandActionBuilder';
 export { CommandActionBuilderWithState } from './helpers/builders/commandActionBuilder';
 export { IStorageClient } from './types/storage';

package/main.ts

@@ -7,67 +7,74 @@ import { Seconds } from './types/timeValues';
 import { IScheduler } from './types/scheduler';
 import { ILogger } from './types/logger';
 import { ActionStateBase } from './entities/states/actionStateBase';
+import { InlineQueryAction } from './entities/actions/inlineQueryAction';
 
-const bots: BotInstance[] = [];
+class BotOrchestrator {
+    bots: BotInstance[] = [];
 
-/**
- * Starts bot
- */
-async function startBot(options: {
-    /** Bot name, used in logging */
-    name: string;
-    /** Path to file containing Telegram Bot token. */
-    tokenFilePath: string;
-    /** Collection of actions that will be executed as a response to message from used. Created using `CommandActionBuilder`.*/
-    commands: CommandAction<ActionStateBase>[];
-    /** Collection of actions that will be executed on timer. Created using `ScheduledActionBuilder`.*/
-    scheduled: ScheduledAction<ActionStateBase>[];
-    /** 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;
-    /** If true, telegram API objects will be logged instead of message content. */
-    verboseLoggingForIncomingMessage?: boolean;
-    services?: {
-        /** Storage client for bot state storage. If not provided, default `JsonFileStorage` will be used. */
-        storageClient?: IStorageClient;
-        /** Logger client for bot logging. If not provided, default `JsonFileStorage` will be used. */
-        logger?: ILogger;
-        /** Scheduler client for bot scheduling. If not provided, default `NodeTimeoutScheduler` will be used. */
-        scheduler?: IScheduler;
-    };
-}) {
-    const token = await readFile(options.tokenFilePath, 'utf8');
-    const bot = new BotInstance({
-        name: options.name,
-        token,
-        commands: options.commands,
-        scheduled: options.scheduled,
-        chats: options.chats,
-        storagePath: options.storagePath,
-        scheduledPeriod: options.scheduledPeriod,
-        verboseLoggingForIncomingMessage:
-            options.verboseLoggingForIncomingMessage,
-        services: {
-            storageClient: options.services?.storageClient,
-            logger: options.services?.logger,
-            scheduler: options.services?.scheduler
-        }
-    });
-    bots.push(bot);
+    /**
+     * Starts bot
+     */
+    async startBot(options: {
+        /** Bot name, used in logging */
+        name: string;
+        /** Path to file containing Telegram Bot token. */
+        tokenFilePath: string;
+        actions: {
+            /** Collection of actions that will be executed as a response to message from used. Created using `CommandActionBuilder`.*/
+            commands: CommandAction<ActionStateBase>[];
+            /** Collection of actions that will be executed on timer. Created using `ScheduledActionBuilder`.*/
+            scheduled: ScheduledAction<ActionStateBase>[];
+            /** 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;
+        /** If true, telegram API objects will be logged instead of message content. */
+        verboseLoggingForIncomingMessage?: boolean;
+        services?: {
+            /** Storage client for bot state storage. If not provided, default `JsonFileStorage` will be used. */
+            storageClient?: IStorageClient;
+            /** Logger client for bot logging. If not provided, default `JsonFileStorage` will be used. */
+            logger?: ILogger;
+            /** Scheduler client for bot scheduling. If not provided, default `NodeTimeoutScheduler` will be used. */
+            scheduler?: IScheduler;
+        };
+    }) {
+        const token = await readFile(options.tokenFilePath, 'utf8');
+        const bot = new BotInstance({
+            name: options.name,
+            token,
+            actions: options.actions,
+            chats: options.chats,
+            storagePath: options.storagePath,
+            scheduledPeriod: options.scheduledPeriod,
+            verboseLoggingForIncomingMessage:
+                options.verboseLoggingForIncomingMessage,
+            services: {
+                storageClient: options.services?.storageClient,
+                logger: options.services?.logger,
+                scheduler: options.services?.scheduler
+            }
+        });
 
-    return bot;
-}
+        this.bots.push(bot);
 
-/**
- * Terminates all scheduled tasks, closes storage connections and stops all bots.
- */
-async function stopBots(reason: string) {
-    for (const bot of bots) {
-        await bot.stop(reason);
+        return bot;
+    }
+
+    /**
+     * Terminates all scheduled tasks, closes storage connections and stops all bots.
+     */
+    async stopBots(reason: string) {
+        for (const bot of this.bots) {
+            await bot.stop(reason);
+        }
     }
 }
 
-export { startBot, stopBots };
+export const botOrchestrator = new BotOrchestrator();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "chz-telegram-bot",
-    "version": "0.1.3",
+    "version": "0.1.4",
     "type": "module",
     "dependencies": {
         "async-sema": "^3.1.1",

package/services/jsonFileStorage.ts

@@ -4,7 +4,7 @@ import { mkdir, readFile, 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/actionWithState';
+import { IActionWithState, ActionKey } from '../types/statefulAction';
 
 export class JsonFileStorage implements IStorageClient {
     private readonly locks = new Map<ActionKey, Semaphore>();

package/services/telegramApi.ts

@@ -41,7 +41,9 @@ export class TelegramApiService {
                         this.logger.errorWithTraceId(
                             this.botName,
                             response.traceId,
-                            response.chatInfo.name,
+                            'chatInfo' in response
+                                ? response.chatInfo.name
+                                : 'Unknown',
                             error,
                             response
                         );
@@ -150,6 +152,13 @@ export class TelegramApiService {
                     }
                 );
                 break;
+            case 'inlineQuery':
+                await this.telegram.answerInlineQuery(
+                    response.queryId,
+                    response.queryResults,
+                    { cache_time: 3600 }
+                );
+                break;
             case 'delay':
                 break;
         }

package/types/handlers.ts

@@ -1,8 +1,14 @@
 import { ChatContext } from '../entities/context/chatContext';
+import { InlineQueryContext } from '../entities/context/inlineQueryContext';
 import { MessageContext } from '../entities/context/messageContext';
 import { IActionState } from './actionState';
 import { CachedValueAccessor } from './cachedValueAccessor';
 
+export type InlineQueryHandler = (
+    /** Context of inline query executed in chat, in response to a message. */
+    ctx: InlineQueryContext
+) => Promise<void>;
+
 export type CommandHandler<TActionState extends IActionState> = (
     /** Context of action executed in chat, in response to a message. */
     ctx: MessageContext<TActionState>,

package/types/response.ts

@@ -1,12 +1,13 @@
 import { ChatInfo } from '../dtos/chatInfo';
 import { DelayResponse } from '../dtos/responses/delay';
 import { ImageMessage } from '../dtos/responses/imageMessage';
+import { InlineQueryResponse } from '../dtos/responses/inlineQueryResponse';
 import { Reaction } from '../dtos/responses/reaction';
 import { TextMessage } from '../dtos/responses/textMessage';
 import { UnpinResponse } from '../dtos/responses/unpin';
 import { VideoMessage } from '../dtos/responses/videoMessage';
 import { IActionState } from './actionState';
-import { IActionWithState } from './actionWithState';
+import { IActionWithState } from './statefulAction';
 import { TraceId } from './trace';
 
 export const BotResponseTypes = {
@@ -15,7 +16,8 @@ export const BotResponseTypes = {
     image: 'image',
     video: 'video',
     react: 'react',
-    delay: 'delay'
+    delay: 'delay',
+    inlineQuery: 'inlineQuery'
 } as const;
 
 export type BotResponse =
@@ -24,6 +26,7 @@ export type BotResponse =
     | TextMessage
     | VideoMessage
     | DelayResponse
+    | InlineQueryResponse
     | ImageMessage;
 
 export interface IChatResponse {

package/types/statelessAction.ts

@@ -0,0 +1,5 @@
+import { ActionKey } from './statefulAction';
+
+export interface IActionWithoutState {
+    readonly key: ActionKey;
+}