chz-telegram-bot 0.0.50 → 0.0.52

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

@@ -1,9 +1,15 @@
 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 {
-    activeTasks: TaskRecord[] = [];
+export class NodeTimeoutScheduler implements IScheduler {
+    private readonly logger!: ILogger;
+    readonly activeTasks: TaskRecord[] = [];
+
+    constructor(logger: ILogger) {
+        this.logger = logger;
+    }
 
     stopAll() {
         this.activeTasks.forEach((task) => {
@@ -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,39 +1,32 @@
 import { Message } from 'telegraf/types';
-import { ChatContext } from '../entities/context/chatContext';
-import { MessageContext } from '../entities/context/messageContext';
-import { inverseRecord as inverseRecord } from '../helpers/inverseRecord';
 import { IStorageClient } from '../types/storage';
-import { Logger } from './logger';
-import { IncomingMessage } from '../entities/incomingMessage';
 import { BotResponse, IReplyMessage } from '../types/response';
 import { Telegram } from 'telegraf/typings/telegram';
 import { setTimeout } from 'timers/promises';
 import { Milliseconds } from '../types/timeValues';
-import { ScheduledAction } from '../entities/actions/scheduledAction';
-import { IActionState } from '../types/actionState';
-import { CommandAction } from '../entities/actions/commandAction';
+import { ILogger } from '../types/logger';
 
 const TELEGRAM_RATELIMIT_DELAY = 35 as Milliseconds;
 
 export class TelegramApiService {
-    isFlushing = false;
-    messageQueue: BotResponse[] = [];
+    private readonly telegram: Telegram;
+    private readonly storage: IStorageClient;
+    private readonly logger: ILogger;
 
-    botName: string;
-    telegram: Telegram;
-    chats: Record<number, string>;
-    storage: IStorageClient;
+    private readonly botName: string;
+    private readonly messageQueue: BotResponse[] = [];
+    isFlushing = false;
 
     constructor(
         botName: string,
         telegram: Telegram,
         storage: IStorageClient,
-        chats: Record<string, number>
+        logger: ILogger
     ) {
         this.telegram = telegram;
         this.botName = botName;
-        this.chats = inverseRecord(chats);
         this.storage = storage;
+        this.logger = logger;
     }
 
     enqueueBatchedResponses(responses: BotResponse[]) {
@@ -56,10 +49,10 @@ export class TelegramApiService {
                 await this.processResponse(message);
                 await setTimeout(TELEGRAM_RATELIMIT_DELAY);
             } catch (error) {
-                Logger.errorWithTraceId(
+                this.logger.errorWithTraceId(
                     this.botName,
                     message.traceId,
-                    this.chats[message.chatId],
+                    message.chatInfo.name,
                     error,
                     message
                 );
@@ -75,14 +68,14 @@ export class TelegramApiService {
     ) {
         if (response.shouldPin) {
             await this.telegram.pinChatMessage(
-                response.chatId,
+                response.chatInfo.id,
                 sentMessage.message_id,
                 { disable_notification: true }
             );
 
             await this.storage.updateStateFor(
                 response.action,
-                response.chatId,
+                response.chatInfo.id,
                 async (state) => {
                     state.pinnedMessages.push(sentMessage.message_id);
                 }
@@ -96,7 +89,7 @@ export class TelegramApiService {
         switch (response.kind) {
             case 'text':
                 sentMessage = await this.telegram.sendMessage(
-                    response.chatId,
+                    response.chatInfo.id,
                     response.content,
                     {
                         reply_to_message_id: response.replyId,
@@ -110,7 +103,7 @@ export class TelegramApiService {
                 break;
             case 'image':
                 sentMessage = await this.telegram.sendPhoto(
-                    response.chatId,
+                    response.chatInfo.id,
                     response.content,
                     response.replyId
                         ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -122,7 +115,7 @@ export class TelegramApiService {
                 break;
             case 'video':
                 sentMessage = await this.telegram.sendVideo(
-                    response.chatId,
+                    response.chatInfo.id,
                     response.content,
                     response.replyId
                         ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -134,7 +127,7 @@ export class TelegramApiService {
                 break;
             case 'react':
                 await this.telegram.setMessageReaction(
-                    response.chatId,
+                    response.chatInfo.id,
                     response.messageId,
                     [
                         {
@@ -148,13 +141,13 @@ export class TelegramApiService {
                 return;
             case 'unpin':
                 await this.telegram.unpinChatMessage(
-                    response.chatId,
+                    response.chatInfo.id,
                     response.messageId
                 );
 
                 await this.storage.updateStateFor(
                     response.action,
-                    response.chatId,
+                    response.chatInfo.id,
                     async (state) => {
                         state.pinnedMessages = state.pinnedMessages.filter(
                             (x) => x != response.messageId
@@ -168,32 +161,4 @@ export class TelegramApiService {
                 }
         }
     }
-
-    initializeContextForMessage<TActionState extends IActionState>(
-        ctx: MessageContext<TActionState>,
-        incomingMessage: IncomingMessage,
-        command: CommandAction<TActionState>
-    ) {
-        return ctx.initializeMessageContext(
-            this.botName,
-            command,
-            incomingMessage,
-            this.storage
-        );
-    }
-
-    initializeContextForChat<TActionState extends IActionState>(
-        ctx: ChatContext<TActionState>,
-        chatId: number,
-        scheduledAction: ScheduledAction<TActionState>
-    ) {
-        return ctx.initializeChatContext(
-            this.botName,
-            scheduledAction,
-            chatId,
-            this.chats[chatId],
-            `Scheduled:${scheduledAction.key}:${chatId}`,
-            this.storage
-        );
-    }
 }

package/types/actionWithState.ts

@@ -3,6 +3,6 @@ import { IActionState } from './actionState';
 export type ActionKey = string & { __brand: 'actionKey' };
 
 export interface IActionWithState<TActionState extends IActionState> {
-    key: ActionKey;
-    stateConstructor: () => TActionState;
+    readonly key: ActionKey;
+    readonly stateConstructor: () => TActionState;
 }

package/types/commandCondition.ts

@@ -3,4 +3,4 @@ import { IActionState } from './actionState';
 
 export type CommandCondition<TActionState extends IActionState> = (
     ctx: MessageContext<TActionState>
-) => Promise<boolean>;
+) => boolean;

package/types/logger.ts

@@ -0,0 +1,24 @@
+export interface ILogger {
+    logObjectWithTraceId(
+        botName: string,
+        traceId: string | number,
+        chatName: string,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        data: any
+    ): void;
+
+    logWithTraceId(
+        botName: string,
+        traceId: string | number,
+        chatName: string,
+        text: string
+    ): void;
+
+    errorWithTraceId<TData>(
+        botName: string,
+        traceId: string | number,
+        chatName: string,
+        errorObj: unknown,
+        extraData?: TData | undefined
+    ): void;
+}

package/types/response.ts

@@ -1,9 +1,10 @@
-import { DelayResponse } from '../entities/responses/delay';
-import { ImageMessage } from '../entities/responses/imageMessage';
-import { Reaction } from '../entities/responses/reaction';
-import { TextMessage } from '../entities/responses/textMessage';
-import { UnpinResponse } from '../entities/responses/unpin';
-import { VideoMessage } from '../entities/responses/videoMessage';
+import { ChatInfo } from '../dtos/chatInfo';
+import { DelayResponse } from '../dtos/responses/delay';
+import { ImageMessage } from '../dtos/responses/imageMessage';
+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';
 
@@ -25,16 +26,16 @@ export type BotResponse =
     | ImageMessage;
 
 export interface IChatResponse {
-    kind: keyof typeof BotResponseTypes;
-    chatId: number;
-    traceId: number | string;
+    readonly kind: keyof typeof BotResponseTypes;
+    readonly chatInfo: ChatInfo;
+    readonly traceId: number | string;
 
-    action: IActionWithState<IActionState>;
+    readonly action: IActionWithState<IActionState>;
 }
 
 export interface IReplyMessage<TType> extends IChatResponse {
-    content: TType;
-    replyId: number | undefined;
-    disableWebPreview: boolean;
-    shouldPin: boolean;
+    readonly content: TType;
+    readonly replyId: number | undefined;
+    readonly disableWebPreview: boolean;
+    readonly shouldPin: boolean;
 }

package/types/scheduler.ts

@@ -0,0 +1,20 @@
+import { Milliseconds } from './timeValues';
+
+export interface IScheduler {
+    stopAll(): void;
+
+    createTask(
+        name: string,
+        action: () => void,
+        interval: Milliseconds,
+        executeRightAway: boolean,
+        ownerName: string
+    ): void;
+
+    createOnetimeTask(
+        name: string,
+        action: () => void,
+        delay: Milliseconds,
+        ownerName: string
+    ): void;
+}

package/types/storage.ts

@@ -1,4 +1,3 @@
-import { ActionExecutionResult } from '../entities/actionExecutionResult';
 import { IActionState } from './actionState';
 import { ActionKey, IActionWithState } from './actionWithState';
 
@@ -23,6 +22,6 @@ export interface IStorageClient {
     saveActionExecutionResult<TActionState extends IActionState>(
         action: IActionWithState<TActionState>,
         chatId: number,
-        transactionResult: ActionExecutionResult<TActionState>
+        state: TActionState
     ): Promise<void>;
 }

package/entities/actionExecutionResult.ts

@@ -1,11 +0,0 @@
-import { IActionState } from '../types/actionState';
-
-export class ActionExecutionResult<TActionState extends IActionState> {
-    data: TActionState;
-    shouldUpdate: boolean;
-
-    constructor(data: TActionState, shouldUpdate: boolean) {
-        this.data = data;
-        this.shouldUpdate = shouldUpdate;
-    }
-}

package/helpers/inverseRecord.ts

@@ -1,7 +0,0 @@
-export function inverseRecord<T extends PropertyKey, U extends PropertyKey>(
-    input: Record<T, U>
-) {
-    return Object.fromEntries(
-        Object.entries(input).map(([key, value]) => [value, key])
-    ) as Record<U, T>;
-}