chz-telegram-bot 0.0.51 → 0.0.52

package/entities/actions/scheduledAction.ts

@@ -7,9 +7,8 @@ import { IActionState } from '../../types/actionState';
 import { IActionWithState, ActionKey } from '../../types/actionWithState';
 import { CachedStateFactory } from '../cachedStateFactory';
 import { ChatContext } from '../context/chatContext';
-import { ActionExecutionResult } from '../../dtos/actionExecutionResult';
-import { Logger } from '../../services/logger';
-import { Scheduler } from '../../services/taskScheduler';
+import { Noop } from '../../helpers/noop';
+import { IScheduler } from '../../types/scheduler';
 
 export class ScheduledAction<TActionState extends IActionState>
     implements IActionWithState<TActionState>
@@ -53,47 +52,45 @@ export class ScheduledAction<TActionState extends IActionState>
             );
 
         if (!this.active || !this.chatsWhitelist.includes(ctx.chatInfo.id))
-            return [];
+            return Noop.NoResponse;
 
         const state = await ctx.storage.getActionState<TActionState>(
             this,
             ctx.chatInfo.id
         );
-        const isAllowedToTrigger = this.shouldTrigger(state);
-
-        if (isAllowedToTrigger) {
-            Logger.logWithTraceId(
-                ctx.botName,
-                ctx.traceId,
-                ctx.chatInfo.name,
-                ` - Executing [${this.name}] in ${ctx.chatInfo.id}`
-            );
 
-            await this.handler(
-                ctx,
-                <TResult>(key: string) =>
-                    this.getCachedValue<TResult>(key, ctx.botName),
-                state
-            );
+        const isAllowedToTrigger = this.checkIfShouldBeExecuted(state);
+        if (!isAllowedToTrigger) return Noop.NoResponse;
 
-            state.lastExecutedDate = moment().valueOf();
+        ctx.logger.logWithTraceId(
+            ctx.botName,
+            ctx.traceId,
+            ctx.chatInfo.name,
+            ` - Executing [${this.name}] in ${ctx.chatInfo.id}`
+        );
 
-            ctx.updateActions.forEach((action) => action(state));
-            await ctx.storage.saveActionExecutionResult(
-                this,
-                ctx.chatInfo.id,
-                new ActionExecutionResult(state, isAllowedToTrigger)
-            );
-        }
+        await this.handler(
+            ctx,
+            <TResult>(key: string) =>
+                this.getCachedValue<TResult>(key, ctx.botName, ctx.scheduler),
+            state
+        );
+
+        state.lastExecutedDate = moment().valueOf();
 
-        ctx.isInitialized = false;
+        await ctx.storage.saveActionExecutionResult(
+            this,
+            ctx.chatInfo.id,
+            state
+        );
 
         return ctx.responses;
     }
 
     private async getCachedValue<TResult>(
         key: string,
-        botName: string
+        botName: string,
+        scheduler: IScheduler
     ): Promise<TResult> {
         if (!this.cachedStateFactories.has(key)) {
             throw new Error(
@@ -122,7 +119,7 @@ export class ScheduledAction<TActionState extends IActionState>
 
             this.cachedState.set(key, value);
 
-            Scheduler.createOnetimeTask(
+            scheduler.createOnetimeTask(
                 `Drop cached value [${this.name} : ${key}]`,
                 () => this.cachedState.delete(key),
                 hoursToMilliseconds(
@@ -137,7 +134,7 @@ export class ScheduledAction<TActionState extends IActionState>
         }
     }
 
-    private shouldTrigger(state: IActionState): boolean {
+    private checkIfShouldBeExecuted(state: IActionState): boolean {
         const startOfToday = moment().startOf('day').valueOf();
         const lastExecutedDate = moment(state.lastExecutedDate);
         const currentTime = moment();

package/entities/botInstance.ts

@@ -10,22 +10,27 @@ import { TelegramApiService } from '../services/telegramApi';
 import { IActionState } from '../types/actionState';
 import { CommandAction } from './actions/commandAction';
 import { ScheduledAction } from './actions/scheduledAction';
-import { Logger } from '../services/logger';
-import { Scheduler } from '../services/taskScheduler';
+import { JsonLogger } from '../services/jsonLogger';
 import { IncomingMessage } from '../dtos/incomingMessage';
 import moment from 'moment';
 import { ChatContext } from './context/chatContext';
 import { MessageContext } from './context/messageContext';
 import { ChatInfo } from '../dtos/chatInfo';
+import { ILogger } from '../types/logger';
+import { IScheduler } from '../types/scheduler';
+import { NodeTimeoutScheduler } from '../services/nodeTimeoutScheduler';
 
 export class BotInstance {
-    readonly name: string;
     private readonly api: TelegramApiService;
+    private readonly storage: IStorageClient;
+    private readonly scheduler: IScheduler;
+    private readonly logger: ILogger;
+
+    readonly name: string;
     private readonly telegraf: Telegraf;
     private readonly commands: CommandAction<IActionState>[];
     private readonly scheduled: ScheduledAction<IActionState>[];
     private readonly chats: Record<string, number>;
-    readonly storage: IStorageClient;
 
     constructor(options: {
         name: string;
@@ -33,10 +38,14 @@ export class BotInstance {
         commands: CommandAction<IActionState>[];
         scheduled: ScheduledAction<IActionState>[];
         chats: Record<string, number>;
-        storageClient?: IStorageClient;
         storagePath?: string;
         scheduledPeriod?: Seconds;
         verboseLoggingForIncomingMessage?: boolean;
+        services?: {
+            storageClient?: IStorageClient;
+            logger?: ILogger;
+            scheduler?: IScheduler;
+        };
     }) {
         this.name = options.name;
         this.commands = options.commands;
@@ -44,21 +53,19 @@ export class BotInstance {
         this.chats = options.chats;
 
         const actions = [...this.commands, ...this.scheduled];
-
-        Logger.logWithTraceId(
-            this.name,
-            `System:Bot-${this.name}-Start`,
-            'System',
-            'Starting bot...'
-        );
         this.telegraf = new Telegraf(options.token);
+        this.logger = options.services?.logger ?? new JsonLogger();
+        this.scheduler =
+            options.services?.scheduler ??
+            new NodeTimeoutScheduler(this.logger);
         this.storage =
-            options.storageClient ??
+            options.services?.storageClient ??
             new JsonFileStorage(options.name, actions, options.storagePath);
         this.api = new TelegramApiService(
             this.name,
             this.telegraf.telegram,
-            this.storage
+            this.storage,
+            this.logger
         );
 
         this.initializeMessageProcessing(
@@ -70,6 +77,12 @@ export class BotInstance {
 
         this.storage.saveMetadata(actions, this.name);
 
+        this.logger.logWithTraceId(
+            this.name,
+            `System:Bot-${this.name}-Start`,
+            'System',
+            'Starting bot...'
+        );
         this.telegraf.launch();
     }
 
@@ -78,7 +91,7 @@ export class BotInstance {
             const now = moment();
 
             if (now.minute() == 0 && now.second() == 0) {
-                Scheduler.createTask(
+                this.scheduler.createTask(
                     'ScheduledProcessing',
                     async () => {
                         await this.runScheduled();
@@ -98,10 +111,10 @@ export class BotInstance {
 
             const delay = nextExecutionTime.diff(now);
 
-            Scheduler.createOnetimeTask(
+            this.scheduler.createOnetimeTask(
                 'ScheduledProcessing_OneTime',
                 async () => {
-                    Scheduler.createTask(
+                    this.scheduler.createTask(
                         'ScheduledProcessing',
                         async () => {
                             await this.runScheduled();
@@ -129,14 +142,14 @@ export class BotInstance {
                 const messageFromId = msg.from?.id ?? 'Unknown';
 
                 if (verboseLoggingForIncomingMessage) {
-                    Logger.logObjectWithTraceId(
+                    this.logger.logObjectWithTraceId(
                         this.name,
                         msg.traceId,
                         msg.chatInfo.name,
                         ctx.update.message
                     );
                 } else {
-                    Logger.logWithTraceId(
+                    this.logger.logWithTraceId(
                         this.name,
                         msg.traceId,
                         msg.chatInfo.name,
@@ -150,19 +163,24 @@ export class BotInstance {
     }
 
     async stop(code: string) {
-        Logger.logWithTraceId(
+        this.logger.logWithTraceId(
             this.name,
             `System:Bot-${this.name}-Stop`,
             'System',
             'Stopping bot...'
         );
 
+        this.scheduler.stopAll();
         await this.storage.close();
         this.telegraf.stop(code);
     }
 
     private async runScheduled() {
-        const ctx = new ChatContext<IActionState>();
+        const ctx = new ChatContext<IActionState>(
+            this.storage,
+            this.logger,
+            this.scheduler
+        );
 
         for (const [chatName, chatId] of Object.entries(this.chats)) {
             for (const scheduledAction of this.scheduled) {
@@ -170,15 +188,15 @@ export class BotInstance {
                     this.name,
                     scheduledAction,
                     new ChatInfo(chatId, chatName),
-                    `Scheduled:${scheduledAction.key}:${chatId}`,
-                    this.storage
+                    `Scheduled:${scheduledAction.key}:${chatId}`
                 );
 
                 try {
                     const responses = await scheduledAction.exec(ctx);
                     this.api.enqueueBatchedResponses(responses);
+                    ctx.isInitialized = false;
                 } catch (error) {
-                    Logger.errorWithTraceId(
+                    this.logger.errorWithTraceId(
                         ctx.botName,
                         ctx.traceId,
                         chatName,
@@ -193,21 +211,21 @@ export class BotInstance {
     }
 
     private async processMessage(msg: IncomingMessage) {
-        const ctx = new MessageContext<IActionState>();
+        const ctx = new MessageContext<IActionState>(
+            this.storage,
+            this.logger,
+            this.scheduler
+        );
 
         for (const commandAction of this.commands) {
-            ctx.initializeMessageContext(
-                this.name,
-                commandAction,
-                msg,
-                this.storage
-            );
+            ctx.initializeMessageContext(this.name, commandAction, msg);
 
             try {
                 const responses = await commandAction.exec(ctx);
                 this.api.enqueueBatchedResponses(responses);
+                ctx.isInitialized = false;
             } catch (error) {
-                Logger.errorWithTraceId(
+                this.logger.errorWithTraceId(
                     ctx.botName,
                     ctx.traceId,
                     ctx.chatInfo.name,

package/entities/context/chatContext.ts

@@ -14,56 +14,60 @@ import { BotResponse } from '../../types/response';
 import { Milliseconds } from '../../types/timeValues';
 import { DelayResponse } from '../../dtos/responses/delay';
 import { ChatInfo } from '../../dtos/chatInfo';
+import { ILogger } from '../../types/logger';
+import { IScheduler } from '../../types/scheduler';
 
 /**
  * Context of action executed in chat.
  */
 export class ChatContext<TActionState extends IActionState> {
     protected action!: IActionWithState<TActionState>;
-    updateActions: Array<(state: TActionState) => void> = [];
+
+    /** 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!: number | string;
     /** Name of a bot that executes this action. */
     botName!: string;
     /** Chat information. */
     chatInfo!: ChatInfo;
-    /** Storage client instance for this bot. */
-    storage!: IStorageClient;
     /** Ordered collection of responses to be processed  */
     responses: BotResponse[] = [];
 
     isInitialized = false;
 
-    constructor() {}
+    constructor(
+        storage: IStorageClient,
+        logger: ILogger,
+        scheduler: IScheduler
+    ) {
+        this.storage = storage;
+        this.logger = logger;
+        this.scheduler = scheduler;
+    }
 
     initializeChatContext(
         botName: string,
         action: IActionWithState<TActionState>,
         chatInfo: ChatInfo,
-        traceId: number | string,
-        storage: IStorageClient
+        traceId: number | string
     ) {
         this.botName = botName;
         this.action = action;
         this.chatInfo = chatInfo;
         this.traceId = traceId;
-        this.storage = storage;
 
-        this.updateActions = [];
         this.isInitialized = true;
         this.responses = [];
 
         return this;
     }
 
-    /**
-     * Manually update the state of an action.
-     * @param stateUpdateAction Function that will modify state.
-     */
-    updateState(stateUpdateAction: (state: TActionState) => void) {
-        this.updateActions.push(stateUpdateAction);
-    }
-
     /**
      * Sends text message to chat after action execution is finished.
      * If multiple responses are sent, they will be sent in the order they were added, with delay of at least 35ms as per Telegram rate-limit.

package/entities/context/messageContext.ts

@@ -15,6 +15,8 @@ import {
 } from '../../types/messageSendingOptions';
 import { IActionWithState, ActionKey } from '../../types/actionWithState';
 import { MessageTypeValue } from '../../types/messageTypes';
+import { ILogger } from '../../types/logger';
+import { IScheduler } from '../../types/scheduler';
 /**
  * Context of action executed in chat, in response to a message
  */
@@ -36,15 +38,18 @@ export class MessageContext<
     /** Type of message being received */
     messageType!: MessageTypeValue;
 
-    constructor() {
-        super();
+    constructor(
+        storage: IStorageClient,
+        logger: ILogger,
+        scheduler: IScheduler
+    ) {
+        super(storage, logger, scheduler);
     }
 
     initializeMessageContext(
         botName: string,
         action: IActionWithState<TActionState>,
-        message: IncomingMessage,
-        storage: IStorageClient
+        message: IncomingMessage
     ) {
         this.messageId = message.message_id;
         this.messageText = message.text ?? '';
@@ -61,8 +66,7 @@ export class MessageContext<
             botName,
             action,
             message.chatInfo,
-            message.traceId,
-            storage
+            message.traceId
         );
     }
 

package/helpers/noop.ts

@@ -1,9 +1,12 @@
+import { BotResponse } from '../types/response';
+
 /* eslint-disable @typescript-eslint/no-unused-vars */
 export class Noop {
-    static async true<T1>(arg1: T1) {
+    static NoResponse: BotResponse[] = [];
+    static true<T1>(arg1: T1) {
         return true;
     }
-    static async false<T1>(arg1: T1) {
+    static false<T1>(arg1: T1) {
         return false;
     }
     static async call<T1, T2>(arg1: T1, arg2: T2): Promise<void>;

package/index.ts

@@ -1,8 +1,10 @@
 export { startBot, stopBots } from './main';
 export { CommandActionBuilder } from './helpers/builders/commandActionBuilder';
 export { CommandActionBuilderWithState } from './helpers/builders/commandActionBuilder';
-export * from './helpers/builders/scheduledActionBuilder';
 export { IStorageClient } from './types/storage';
+export { ILogger } from './types/logger';
+export { IScheduler } from './types/scheduler';
+export * from './helpers/builders/scheduledActionBuilder';
 export * from './types/actionState';
 export * from './entities/states/actionStateBase';
 export { Hours, Milliseconds, Seconds } from './types/timeValues';

package/main.ts

@@ -1,19 +1,15 @@
 import { readFile } from 'fs/promises';
 import { IStorageClient } from './types/storage';
-import { Logger } from './services/logger';
 import { CommandAction } from './entities/actions/commandAction';
 import { ScheduledAction } from './entities/actions/scheduledAction';
 import { IActionState } from './types/actionState';
-import { Scheduler } from './services/taskScheduler';
 import { BotInstance } from './entities/botInstance';
 import { Seconds } from './types/timeValues';
+import { IScheduler } from './types/scheduler';
+import { ILogger } from './types/logger';
 
 const bots: BotInstance[] = [];
 
-function log(text: string) {
-    Logger.logWithTraceId('ALL BOTS', 'System:Bot', 'System', text);
-}
-
 /**
  * Starts bot
  */
@@ -28,14 +24,20 @@ async function startBot(options: {
     scheduled: ScheduledAction<IActionState>[];
     /** Object containing chat name and chat id pairs. Used for logging and execution of scheduled action. */
     chats: Record<string, number>;
-    /** Storage client for bot state storage. If not provided, default `JsonFileStorage` will be used. */
-    storageClient?: IStorageClient;
     /** 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({
@@ -44,11 +46,15 @@ async function startBot(options: {
         commands: options.commands,
         scheduled: options.scheduled,
         chats: options.chats,
-        storageClient: options.storageClient,
         storagePath: options.storagePath,
         scheduledPeriod: options.scheduledPeriod,
         verboseLoggingForIncomingMessage:
-            options.verboseLoggingForIncomingMessage
+            options.verboseLoggingForIncomingMessage,
+        services: {
+            storageClient: options.services?.storageClient,
+            logger: options.services?.logger,
+            scheduler: options.services?.scheduler
+        }
     });
     bots.push(bot);
 
@@ -59,11 +65,6 @@ async function startBot(options: {
  * Terminates all scheduled tasks, closes storage connections and stops all bots.
  */
 async function stopBots(reason: string) {
-    log(`Recieved termination code: ${reason}`);
-    Scheduler.stopAll();
-    log('Acquiring storage semaphore...');
-
-    log('Stopping bots...');
     for (const bot of bots) {
         await bot.stop(reason);
     }

package/package.json

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

package/services/jsonFileStorage.ts

@@ -3,7 +3,6 @@ import { dirname } from 'path';
 import { mkdir, readFile, writeFile } from 'fs/promises';
 import { Sema as Semaphore } from 'async-sema';
 import { IStorageClient } from '../types/storage';
-import { ActionExecutionResult } from '../dtos/actionExecutionResult';
 import { IActionState } from '../types/actionState';
 import { IActionWithState, ActionKey } from '../types/actionWithState';
 
@@ -129,15 +128,14 @@ export class JsonFileStorage implements IStorageClient {
     async saveActionExecutionResult<TActionState extends IActionState>(
         action: IActionWithState<TActionState>,
         chatId: number,
-        transactionResult: ActionExecutionResult<TActionState>
+        state: TActionState
     ) {
         await this.lock(action.key, async () => {
             const data = await this.loadInternal<TActionState>(action.key);
 
-            if (transactionResult.shouldUpdate) {
-                data[chatId] = transactionResult.data;
-                await this.save(data, action.key);
-            }
+            data[chatId] = state;
+
+            await this.save(data, action.key);
         });
     }
 

package/services/{logger.ts → jsonLogger.ts}

@@ -1,4 +1,6 @@
-class JsonLogger {
+import { ILogger } from '../types/logger';
+
+export class JsonLogger implements ILogger {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     private serializeError(error: any) {
         const plainObject: Record<string, unknown> = {};
@@ -46,5 +48,3 @@ class JsonLogger {
         );
     }
 }
-
-export const Logger = new JsonLogger();

package/services/{taskScheduler.ts → nodeTimeoutScheduler.ts}

@@ -1,10 +1,16 @@
 import { TaskRecord } from '../entities/taskRecord';
+import { ILogger } from '../types/logger';
+import { IScheduler } from '../types/scheduler';
 import { Milliseconds } from '../types/timeValues';
-import { Logger } from './logger';
 
-class TaskScheduler {
+export class NodeTimeoutScheduler implements IScheduler {
+    private readonly logger!: ILogger;
     readonly activeTasks: TaskRecord[] = [];
 
+    constructor(logger: ILogger) {
+        this.logger = logger;
+    }
+
     stopAll() {
         this.activeTasks.forEach((task) => {
             clearInterval(task.taskId);
@@ -25,7 +31,7 @@ class TaskScheduler {
             setImmediate(action);
         }
 
-        Logger.logWithTraceId(
+        this.logger.logWithTraceId(
             ownerName,
             `System:TaskScheduler-${ownerName}-${name}`,
             'System',
@@ -42,7 +48,7 @@ class TaskScheduler {
         ownerName: string
     ) {
         const actionWrapper = () => {
-            Logger.logWithTraceId(
+            this.logger.logWithTraceId(
                 ownerName,
                 `System:TaskScheduler-${ownerName}-${name}`,
                 'System',
@@ -52,7 +58,7 @@ class TaskScheduler {
         };
         const taskId = setTimeout(actionWrapper, delay);
 
-        Logger.logWithTraceId(
+        this.logger.logWithTraceId(
             ownerName,
             `System:TaskScheduler-${ownerName}-${name}`,
             'System',
@@ -60,5 +66,3 @@ class TaskScheduler {
         );
     }
 }
-
-export const Scheduler = new TaskScheduler();

package/services/telegramApi.ts

@@ -1,25 +1,32 @@
 import { Message } from 'telegraf/types';
 import { IStorageClient } from '../types/storage';
-import { Logger } from './logger';
 import { BotResponse, IReplyMessage } from '../types/response';
 import { Telegram } from 'telegraf/typings/telegram';
 import { setTimeout } from 'timers/promises';
 import { Milliseconds } from '../types/timeValues';
+import { ILogger } from '../types/logger';
 
 const TELEGRAM_RATELIMIT_DELAY = 35 as Milliseconds;
 
 export class TelegramApiService {
-    isFlushing = false;
-    readonly messageQueue: BotResponse[] = [];
+    private readonly telegram: Telegram;
+    private readonly storage: IStorageClient;
+    private readonly logger: ILogger;
 
-    readonly botName: string;
-    readonly telegram: Telegram;
-    readonly storage: IStorageClient;
+    private readonly botName: string;
+    private readonly messageQueue: BotResponse[] = [];
+    isFlushing = false;
 
-    constructor(botName: string, telegram: Telegram, storage: IStorageClient) {
+    constructor(
+        botName: string,
+        telegram: Telegram,
+        storage: IStorageClient,
+        logger: ILogger
+    ) {
         this.telegram = telegram;
         this.botName = botName;
         this.storage = storage;
+        this.logger = logger;
     }
 
     enqueueBatchedResponses(responses: BotResponse[]) {
@@ -42,7 +49,7 @@ export class TelegramApiService {
                 await this.processResponse(message);
                 await setTimeout(TELEGRAM_RATELIMIT_DELAY);
             } catch (error) {
-                Logger.errorWithTraceId(
+                this.logger.errorWithTraceId(
                     this.botName,
                     message.traceId,
                     message.chatInfo.name,